Vulkan-Hpp
vulkan_raii.hpp
Go to the documentation of this file.
1 // Copyright 2015-2024 The Khronos Group Inc.
2 //
3 // SPDX-License-Identifier: Apache-2.0 OR MIT
4 //
5 
6 // This header is generated from the Khronos Vulkan XML API Registry.
7 
8 #ifndef VULKAN_RAII_HPP
9 #define VULKAN_RAII_HPP
10 
11 #include <memory> // std::unique_ptr
12 #include <utility> // std::exchange, std::forward
13 #include <vulkan/vulkan.hpp>
14 
15 #if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
16 namespace VULKAN_HPP_NAMESPACE
17 {
18  namespace VULKAN_HPP_RAII_NAMESPACE
19  {
20  template <class T, class U = T>
22  {
23 # if ( 14 <= VULKAN_HPP_CPP_VERSION )
24  return std::exchange<T>( obj, std::forward<U>( newValue ) );
25 # else
26  T oldValue = std::move( obj );
27  obj = std::forward<U>( newValue );
28  return oldValue;
29 # endif
30  }
31 
32  template <class T>
34  {
35  public:
36 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
37  using Type = VULKAN_HPP_EXPECTED<T, VULKAN_HPP_NAMESPACE::Result>;
38 # else
39  using Type = T;
40 # endif
41  };
42 
44  {
45  public:
47  : vkGetInstanceProcAddr( getProcAddr )
48  //=== VK_VERSION_1_0 ===
49  , vkCreateInstance( PFN_vkCreateInstance( getProcAddr( NULL, "vkCreateInstance" ) ) )
50  , vkEnumerateInstanceExtensionProperties( PFN_vkEnumerateInstanceExtensionProperties( getProcAddr( NULL, "vkEnumerateInstanceExtensionProperties" ) ) )
51  , vkEnumerateInstanceLayerProperties( PFN_vkEnumerateInstanceLayerProperties( getProcAddr( NULL, "vkEnumerateInstanceLayerProperties" ) ) )
52  //=== VK_VERSION_1_1 ===
53  , vkEnumerateInstanceVersion( PFN_vkEnumerateInstanceVersion( getProcAddr( NULL, "vkEnumerateInstanceVersion" ) ) )
54  {
55  }
56 
57  public:
59 
60  //=== VK_VERSION_1_0 ===
64 
65  //=== VK_VERSION_1_1 ===
67  };
68 
70  {
71  public:
73  {
74  //=== VK_VERSION_1_0 ===
75  vkDestroyInstance = PFN_vkDestroyInstance( vkGetInstanceProcAddr( instance, "vkDestroyInstance" ) );
76  vkEnumeratePhysicalDevices = PFN_vkEnumeratePhysicalDevices( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDevices" ) );
77  vkGetPhysicalDeviceFeatures = PFN_vkGetPhysicalDeviceFeatures( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures" ) );
79  PFN_vkGetPhysicalDeviceFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties" ) );
81  PFN_vkGetPhysicalDeviceImageFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties" ) );
82  vkGetPhysicalDeviceProperties = PFN_vkGetPhysicalDeviceProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties" ) );
84  PFN_vkGetPhysicalDeviceQueueFamilyProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties" ) );
86  PFN_vkGetPhysicalDeviceMemoryProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties" ) );
87  vkCreateDevice = PFN_vkCreateDevice( vkGetInstanceProcAddr( instance, "vkCreateDevice" ) );
89  PFN_vkEnumerateDeviceExtensionProperties( vkGetInstanceProcAddr( instance, "vkEnumerateDeviceExtensionProperties" ) );
90  vkEnumerateDeviceLayerProperties = PFN_vkEnumerateDeviceLayerProperties( vkGetInstanceProcAddr( instance, "vkEnumerateDeviceLayerProperties" ) );
92  PFN_vkGetPhysicalDeviceSparseImageFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties" ) );
93 
94  //=== VK_VERSION_1_1 ===
95  vkEnumeratePhysicalDeviceGroups = PFN_vkEnumeratePhysicalDeviceGroups( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceGroups" ) );
96  vkGetPhysicalDeviceFeatures2 = PFN_vkGetPhysicalDeviceFeatures2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures2" ) );
97  vkGetPhysicalDeviceProperties2 = PFN_vkGetPhysicalDeviceProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties2" ) );
99  PFN_vkGetPhysicalDeviceFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties2" ) );
101  PFN_vkGetPhysicalDeviceImageFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties2" ) );
103  PFN_vkGetPhysicalDeviceQueueFamilyProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties2" ) );
105  PFN_vkGetPhysicalDeviceMemoryProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties2" ) );
107  PFN_vkGetPhysicalDeviceSparseImageFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties2" ) );
109  PFN_vkGetPhysicalDeviceExternalBufferProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalBufferProperties" ) );
111  PFN_vkGetPhysicalDeviceExternalFenceProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalFenceProperties" ) );
113  PFN_vkGetPhysicalDeviceExternalSemaphoreProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalSemaphoreProperties" ) );
114 
115  //=== VK_VERSION_1_3 ===
116  vkGetPhysicalDeviceToolProperties = PFN_vkGetPhysicalDeviceToolProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceToolProperties" ) );
117 
118  //=== VK_KHR_surface ===
119  vkDestroySurfaceKHR = PFN_vkDestroySurfaceKHR( vkGetInstanceProcAddr( instance, "vkDestroySurfaceKHR" ) );
121  PFN_vkGetPhysicalDeviceSurfaceSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceSupportKHR" ) );
123  PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR" ) );
125  PFN_vkGetPhysicalDeviceSurfaceFormatsKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceFormatsKHR" ) );
127  PFN_vkGetPhysicalDeviceSurfacePresentModesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfacePresentModesKHR" ) );
128 
129  //=== VK_KHR_swapchain ===
131  PFN_vkGetPhysicalDevicePresentRectanglesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDevicePresentRectanglesKHR" ) );
132 
133  //=== VK_KHR_display ===
135  PFN_vkGetPhysicalDeviceDisplayPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPropertiesKHR" ) );
137  PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR" ) );
139  PFN_vkGetDisplayPlaneSupportedDisplaysKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneSupportedDisplaysKHR" ) );
140  vkGetDisplayModePropertiesKHR = PFN_vkGetDisplayModePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayModePropertiesKHR" ) );
141  vkCreateDisplayModeKHR = PFN_vkCreateDisplayModeKHR( vkGetInstanceProcAddr( instance, "vkCreateDisplayModeKHR" ) );
142  vkGetDisplayPlaneCapabilitiesKHR = PFN_vkGetDisplayPlaneCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneCapabilitiesKHR" ) );
143  vkCreateDisplayPlaneSurfaceKHR = PFN_vkCreateDisplayPlaneSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateDisplayPlaneSurfaceKHR" ) );
144 
145 # if defined( VK_USE_PLATFORM_XLIB_KHR )
146  //=== VK_KHR_xlib_surface ===
147  vkCreateXlibSurfaceKHR = PFN_vkCreateXlibSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateXlibSurfaceKHR" ) );
148  vkGetPhysicalDeviceXlibPresentationSupportKHR =
149  PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR" ) );
150 # endif /*VK_USE_PLATFORM_XLIB_KHR*/
151 
152 # if defined( VK_USE_PLATFORM_XCB_KHR )
153  //=== VK_KHR_xcb_surface ===
154  vkCreateXcbSurfaceKHR = PFN_vkCreateXcbSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateXcbSurfaceKHR" ) );
155  vkGetPhysicalDeviceXcbPresentationSupportKHR =
156  PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR" ) );
157 # endif /*VK_USE_PLATFORM_XCB_KHR*/
158 
159 # if defined( VK_USE_PLATFORM_WAYLAND_KHR )
160  //=== VK_KHR_wayland_surface ===
161  vkCreateWaylandSurfaceKHR = PFN_vkCreateWaylandSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateWaylandSurfaceKHR" ) );
162  vkGetPhysicalDeviceWaylandPresentationSupportKHR =
163  PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceWaylandPresentationSupportKHR" ) );
164 # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
165 
166 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
167  //=== VK_KHR_android_surface ===
168  vkCreateAndroidSurfaceKHR = PFN_vkCreateAndroidSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateAndroidSurfaceKHR" ) );
169 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
170 
171 # if defined( VK_USE_PLATFORM_WIN32_KHR )
172  //=== VK_KHR_win32_surface ===
173  vkCreateWin32SurfaceKHR = PFN_vkCreateWin32SurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateWin32SurfaceKHR" ) );
174  vkGetPhysicalDeviceWin32PresentationSupportKHR =
175  PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceWin32PresentationSupportKHR" ) );
176 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
177 
178  //=== VK_EXT_debug_report ===
179  vkCreateDebugReportCallbackEXT = PFN_vkCreateDebugReportCallbackEXT( vkGetInstanceProcAddr( instance, "vkCreateDebugReportCallbackEXT" ) );
180  vkDestroyDebugReportCallbackEXT = PFN_vkDestroyDebugReportCallbackEXT( vkGetInstanceProcAddr( instance, "vkDestroyDebugReportCallbackEXT" ) );
181  vkDebugReportMessageEXT = PFN_vkDebugReportMessageEXT( vkGetInstanceProcAddr( instance, "vkDebugReportMessageEXT" ) );
182 
183  //=== VK_KHR_video_queue ===
185  PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoCapabilitiesKHR" ) );
187  PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoFormatPropertiesKHR" ) );
188 
189 # if defined( VK_USE_PLATFORM_GGP )
190  //=== VK_GGP_stream_descriptor_surface ===
191  vkCreateStreamDescriptorSurfaceGGP = PFN_vkCreateStreamDescriptorSurfaceGGP( vkGetInstanceProcAddr( instance, "vkCreateStreamDescriptorSurfaceGGP" ) );
192 # endif /*VK_USE_PLATFORM_GGP*/
193 
194  //=== VK_NV_external_memory_capabilities ===
196  PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV" ) );
197 
198  //=== VK_KHR_get_physical_device_properties2 ===
199  vkGetPhysicalDeviceFeatures2KHR = PFN_vkGetPhysicalDeviceFeatures2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures2KHR" ) );
202  vkGetPhysicalDeviceProperties2KHR = PFN_vkGetPhysicalDeviceProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties2KHR" ) );
206  PFN_vkGetPhysicalDeviceFormatProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties2KHR" ) );
210  PFN_vkGetPhysicalDeviceImageFormatProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties2KHR" ) );
214  PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties2KHR" ) );
218  PFN_vkGetPhysicalDeviceMemoryProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties2KHR" ) );
222  PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR" ) );
225 
226 # if defined( VK_USE_PLATFORM_VI_NN )
227  //=== VK_NN_vi_surface ===
228  vkCreateViSurfaceNN = PFN_vkCreateViSurfaceNN( vkGetInstanceProcAddr( instance, "vkCreateViSurfaceNN" ) );
229 # endif /*VK_USE_PLATFORM_VI_NN*/
230 
231  //=== VK_KHR_device_group_creation ===
232  vkEnumeratePhysicalDeviceGroupsKHR = PFN_vkEnumeratePhysicalDeviceGroupsKHR( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceGroupsKHR" ) );
235 
236  //=== VK_KHR_external_memory_capabilities ===
238  PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalBufferPropertiesKHR" ) );
241 
242  //=== VK_KHR_external_semaphore_capabilities ===
244  PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR" ) );
247 
248  //=== VK_EXT_direct_mode_display ===
249  vkReleaseDisplayEXT = PFN_vkReleaseDisplayEXT( vkGetInstanceProcAddr( instance, "vkReleaseDisplayEXT" ) );
250 
251 # if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
252  //=== VK_EXT_acquire_xlib_display ===
253  vkAcquireXlibDisplayEXT = PFN_vkAcquireXlibDisplayEXT( vkGetInstanceProcAddr( instance, "vkAcquireXlibDisplayEXT" ) );
254  vkGetRandROutputDisplayEXT = PFN_vkGetRandROutputDisplayEXT( vkGetInstanceProcAddr( instance, "vkGetRandROutputDisplayEXT" ) );
255 # endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
256 
257  //=== VK_EXT_display_surface_counter ===
259  PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilities2EXT" ) );
260 
261  //=== VK_KHR_external_fence_capabilities ===
263  PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalFencePropertiesKHR" ) );
266 
267  //=== VK_KHR_performance_query ===
269  vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR" ) );
271  vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR" ) );
272 
273  //=== VK_KHR_get_surface_capabilities2 ===
275  PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilities2KHR" ) );
277  PFN_vkGetPhysicalDeviceSurfaceFormats2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceFormats2KHR" ) );
278 
279  //=== VK_KHR_get_display_properties2 ===
281  PFN_vkGetPhysicalDeviceDisplayProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayProperties2KHR" ) );
283  PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR" ) );
284  vkGetDisplayModeProperties2KHR = PFN_vkGetDisplayModeProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetDisplayModeProperties2KHR" ) );
285  vkGetDisplayPlaneCapabilities2KHR = PFN_vkGetDisplayPlaneCapabilities2KHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneCapabilities2KHR" ) );
286 
287 # if defined( VK_USE_PLATFORM_IOS_MVK )
288  //=== VK_MVK_ios_surface ===
289  vkCreateIOSSurfaceMVK = PFN_vkCreateIOSSurfaceMVK( vkGetInstanceProcAddr( instance, "vkCreateIOSSurfaceMVK" ) );
290 # endif /*VK_USE_PLATFORM_IOS_MVK*/
291 
292 # if defined( VK_USE_PLATFORM_MACOS_MVK )
293  //=== VK_MVK_macos_surface ===
294  vkCreateMacOSSurfaceMVK = PFN_vkCreateMacOSSurfaceMVK( vkGetInstanceProcAddr( instance, "vkCreateMacOSSurfaceMVK" ) );
295 # endif /*VK_USE_PLATFORM_MACOS_MVK*/
296 
297  //=== VK_EXT_debug_utils ===
298  vkCreateDebugUtilsMessengerEXT = PFN_vkCreateDebugUtilsMessengerEXT( vkGetInstanceProcAddr( instance, "vkCreateDebugUtilsMessengerEXT" ) );
299  vkDestroyDebugUtilsMessengerEXT = PFN_vkDestroyDebugUtilsMessengerEXT( vkGetInstanceProcAddr( instance, "vkDestroyDebugUtilsMessengerEXT" ) );
300  vkSubmitDebugUtilsMessageEXT = PFN_vkSubmitDebugUtilsMessageEXT( vkGetInstanceProcAddr( instance, "vkSubmitDebugUtilsMessageEXT" ) );
301 
302  //=== VK_EXT_sample_locations ===
304  PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMultisamplePropertiesEXT" ) );
305 
306  //=== VK_EXT_calibrated_timestamps ===
308  PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT" ) );
311 
312 # if defined( VK_USE_PLATFORM_FUCHSIA )
313  //=== VK_FUCHSIA_imagepipe_surface ===
314  vkCreateImagePipeSurfaceFUCHSIA = PFN_vkCreateImagePipeSurfaceFUCHSIA( vkGetInstanceProcAddr( instance, "vkCreateImagePipeSurfaceFUCHSIA" ) );
315 # endif /*VK_USE_PLATFORM_FUCHSIA*/
316 
317 # if defined( VK_USE_PLATFORM_METAL_EXT )
318  //=== VK_EXT_metal_surface ===
319  vkCreateMetalSurfaceEXT = PFN_vkCreateMetalSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateMetalSurfaceEXT" ) );
320 # endif /*VK_USE_PLATFORM_METAL_EXT*/
321 
322  //=== VK_KHR_fragment_shading_rate ===
324  PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFragmentShadingRatesKHR" ) );
325 
326  //=== VK_EXT_tooling_info ===
328  PFN_vkGetPhysicalDeviceToolPropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceToolPropertiesEXT" ) );
331 
332  //=== VK_NV_cooperative_matrix ===
334  PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV" ) );
335 
336  //=== VK_NV_coverage_reduction_mode ===
338  vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" ) );
339 
340 # if defined( VK_USE_PLATFORM_WIN32_KHR )
341  //=== VK_EXT_full_screen_exclusive ===
342  vkGetPhysicalDeviceSurfacePresentModes2EXT =
343  PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfacePresentModes2EXT" ) );
344 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
345 
346  //=== VK_EXT_headless_surface ===
347  vkCreateHeadlessSurfaceEXT = PFN_vkCreateHeadlessSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateHeadlessSurfaceEXT" ) );
348 
349  //=== VK_EXT_acquire_drm_display ===
350  vkAcquireDrmDisplayEXT = PFN_vkAcquireDrmDisplayEXT( vkGetInstanceProcAddr( instance, "vkAcquireDrmDisplayEXT" ) );
351  vkGetDrmDisplayEXT = PFN_vkGetDrmDisplayEXT( vkGetInstanceProcAddr( instance, "vkGetDrmDisplayEXT" ) );
352 
353  //=== VK_KHR_video_encode_queue ===
355  vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR" ) );
356 
357 # if defined( VK_USE_PLATFORM_WIN32_KHR )
358  //=== VK_NV_acquire_winrt_display ===
359  vkAcquireWinrtDisplayNV = PFN_vkAcquireWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkAcquireWinrtDisplayNV" ) );
360  vkGetWinrtDisplayNV = PFN_vkGetWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkGetWinrtDisplayNV" ) );
361 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
362 
363 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
364  //=== VK_EXT_directfb_surface ===
365  vkCreateDirectFBSurfaceEXT = PFN_vkCreateDirectFBSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateDirectFBSurfaceEXT" ) );
366  vkGetPhysicalDeviceDirectFBPresentationSupportEXT =
367  PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDirectFBPresentationSupportEXT" ) );
368 # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
369 
370 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
371  //=== VK_QNX_screen_surface ===
372  vkCreateScreenSurfaceQNX = PFN_vkCreateScreenSurfaceQNX( vkGetInstanceProcAddr( instance, "vkCreateScreenSurfaceQNX" ) );
373  vkGetPhysicalDeviceScreenPresentationSupportQNX =
374  PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceScreenPresentationSupportQNX" ) );
375 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/
376 
377  //=== VK_NV_optical_flow ===
379  PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceOpticalFlowImageFormatsNV" ) );
380 
381  //=== VK_KHR_cooperative_matrix ===
383  PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR" ) );
384 
385  //=== VK_KHR_calibrated_timestamps ===
387  PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR" ) );
388 
389  vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr( vkGetInstanceProcAddr( instance, "vkGetDeviceProcAddr" ) );
390  }
391 
392  public:
393  //=== VK_VERSION_1_0 ===
407 
408  //=== VK_VERSION_1_1 ===
420 
421  //=== VK_VERSION_1_3 ===
423 
424  //=== VK_KHR_surface ===
430 
431  //=== VK_KHR_swapchain ===
433 
434  //=== VK_KHR_display ===
442 
443 # if defined( VK_USE_PLATFORM_XLIB_KHR )
444  //=== VK_KHR_xlib_surface ===
445  PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR = 0;
446  PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR vkGetPhysicalDeviceXlibPresentationSupportKHR = 0;
447 # else
448  PFN_dummy vkCreateXlibSurfaceKHR_placeholder = 0;
449  PFN_dummy vkGetPhysicalDeviceXlibPresentationSupportKHR_placeholder = 0;
450 # endif /*VK_USE_PLATFORM_XLIB_KHR*/
451 
452 # if defined( VK_USE_PLATFORM_XCB_KHR )
453  //=== VK_KHR_xcb_surface ===
454  PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR = 0;
455  PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR vkGetPhysicalDeviceXcbPresentationSupportKHR = 0;
456 # else
457  PFN_dummy vkCreateXcbSurfaceKHR_placeholder = 0;
458  PFN_dummy vkGetPhysicalDeviceXcbPresentationSupportKHR_placeholder = 0;
459 # endif /*VK_USE_PLATFORM_XCB_KHR*/
460 
461 # if defined( VK_USE_PLATFORM_WAYLAND_KHR )
462  //=== VK_KHR_wayland_surface ===
463  PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR = 0;
464  PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR vkGetPhysicalDeviceWaylandPresentationSupportKHR = 0;
465 # else
466  PFN_dummy vkCreateWaylandSurfaceKHR_placeholder = 0;
467  PFN_dummy vkGetPhysicalDeviceWaylandPresentationSupportKHR_placeholder = 0;
468 # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
469 
470 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
471  //=== VK_KHR_android_surface ===
472  PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR = 0;
473 # else
474  PFN_dummy vkCreateAndroidSurfaceKHR_placeholder = 0;
475 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
476 
477 # if defined( VK_USE_PLATFORM_WIN32_KHR )
478  //=== VK_KHR_win32_surface ===
479  PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR = 0;
480  PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR vkGetPhysicalDeviceWin32PresentationSupportKHR = 0;
481 # else
482  PFN_dummy vkCreateWin32SurfaceKHR_placeholder = 0;
483  PFN_dummy vkGetPhysicalDeviceWin32PresentationSupportKHR_placeholder = 0;
484 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
485 
486  //=== VK_EXT_debug_report ===
490 
491  //=== VK_KHR_video_queue ===
494 
495 # if defined( VK_USE_PLATFORM_GGP )
496  //=== VK_GGP_stream_descriptor_surface ===
497  PFN_vkCreateStreamDescriptorSurfaceGGP vkCreateStreamDescriptorSurfaceGGP = 0;
498 # else
499  PFN_dummy vkCreateStreamDescriptorSurfaceGGP_placeholder = 0;
500 # endif /*VK_USE_PLATFORM_GGP*/
501 
502  //=== VK_NV_external_memory_capabilities ===
504 
505  //=== VK_KHR_get_physical_device_properties2 ===
513 
514 # if defined( VK_USE_PLATFORM_VI_NN )
515  //=== VK_NN_vi_surface ===
516  PFN_vkCreateViSurfaceNN vkCreateViSurfaceNN = 0;
517 # else
518  PFN_dummy vkCreateViSurfaceNN_placeholder = 0;
519 # endif /*VK_USE_PLATFORM_VI_NN*/
520 
521  //=== VK_KHR_device_group_creation ===
523 
524  //=== VK_KHR_external_memory_capabilities ===
526 
527  //=== VK_KHR_external_semaphore_capabilities ===
529 
530  //=== VK_EXT_direct_mode_display ===
532 
533 # if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
534  //=== VK_EXT_acquire_xlib_display ===
535  PFN_vkAcquireXlibDisplayEXT vkAcquireXlibDisplayEXT = 0;
536  PFN_vkGetRandROutputDisplayEXT vkGetRandROutputDisplayEXT = 0;
537 # else
538  PFN_dummy vkAcquireXlibDisplayEXT_placeholder = 0;
539  PFN_dummy vkGetRandROutputDisplayEXT_placeholder = 0;
540 # endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
541 
542  //=== VK_EXT_display_surface_counter ===
544 
545  //=== VK_KHR_external_fence_capabilities ===
547 
548  //=== VK_KHR_performance_query ===
551 
552  //=== VK_KHR_get_surface_capabilities2 ===
555 
556  //=== VK_KHR_get_display_properties2 ===
561 
562 # if defined( VK_USE_PLATFORM_IOS_MVK )
563  //=== VK_MVK_ios_surface ===
564  PFN_vkCreateIOSSurfaceMVK vkCreateIOSSurfaceMVK = 0;
565 # else
566  PFN_dummy vkCreateIOSSurfaceMVK_placeholder = 0;
567 # endif /*VK_USE_PLATFORM_IOS_MVK*/
568 
569 # if defined( VK_USE_PLATFORM_MACOS_MVK )
570  //=== VK_MVK_macos_surface ===
571  PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK = 0;
572 # else
573  PFN_dummy vkCreateMacOSSurfaceMVK_placeholder = 0;
574 # endif /*VK_USE_PLATFORM_MACOS_MVK*/
575 
576  //=== VK_EXT_debug_utils ===
580 
581  //=== VK_EXT_sample_locations ===
583 
584  //=== VK_EXT_calibrated_timestamps ===
586 
587 # if defined( VK_USE_PLATFORM_FUCHSIA )
588  //=== VK_FUCHSIA_imagepipe_surface ===
589  PFN_vkCreateImagePipeSurfaceFUCHSIA vkCreateImagePipeSurfaceFUCHSIA = 0;
590 # else
591  PFN_dummy vkCreateImagePipeSurfaceFUCHSIA_placeholder = 0;
592 # endif /*VK_USE_PLATFORM_FUCHSIA*/
593 
594 # if defined( VK_USE_PLATFORM_METAL_EXT )
595  //=== VK_EXT_metal_surface ===
596  PFN_vkCreateMetalSurfaceEXT vkCreateMetalSurfaceEXT = 0;
597 # else
598  PFN_dummy vkCreateMetalSurfaceEXT_placeholder = 0;
599 # endif /*VK_USE_PLATFORM_METAL_EXT*/
600 
601  //=== VK_KHR_fragment_shading_rate ===
603 
604  //=== VK_EXT_tooling_info ===
606 
607  //=== VK_NV_cooperative_matrix ===
609 
610  //=== VK_NV_coverage_reduction_mode ===
612 
613 # if defined( VK_USE_PLATFORM_WIN32_KHR )
614  //=== VK_EXT_full_screen_exclusive ===
615  PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT vkGetPhysicalDeviceSurfacePresentModes2EXT = 0;
616 # else
617  PFN_dummy vkGetPhysicalDeviceSurfacePresentModes2EXT_placeholder = 0;
618 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
619 
620  //=== VK_EXT_headless_surface ===
622 
623  //=== VK_EXT_acquire_drm_display ===
626 
627  //=== VK_KHR_video_encode_queue ===
629 
630 # if defined( VK_USE_PLATFORM_WIN32_KHR )
631  //=== VK_NV_acquire_winrt_display ===
632  PFN_vkAcquireWinrtDisplayNV vkAcquireWinrtDisplayNV = 0;
633  PFN_vkGetWinrtDisplayNV vkGetWinrtDisplayNV = 0;
634 # else
635  PFN_dummy vkAcquireWinrtDisplayNV_placeholder = 0;
636  PFN_dummy vkGetWinrtDisplayNV_placeholder = 0;
637 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
638 
639 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
640  //=== VK_EXT_directfb_surface ===
641  PFN_vkCreateDirectFBSurfaceEXT vkCreateDirectFBSurfaceEXT = 0;
642  PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT vkGetPhysicalDeviceDirectFBPresentationSupportEXT = 0;
643 # else
644  PFN_dummy vkCreateDirectFBSurfaceEXT_placeholder = 0;
645  PFN_dummy vkGetPhysicalDeviceDirectFBPresentationSupportEXT_placeholder = 0;
646 # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
647 
648 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
649  //=== VK_QNX_screen_surface ===
650  PFN_vkCreateScreenSurfaceQNX vkCreateScreenSurfaceQNX = 0;
651  PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX vkGetPhysicalDeviceScreenPresentationSupportQNX = 0;
652 # else
653  PFN_dummy vkCreateScreenSurfaceQNX_placeholder = 0;
654  PFN_dummy vkGetPhysicalDeviceScreenPresentationSupportQNX_placeholder = 0;
655 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/
656 
657  //=== VK_NV_optical_flow ===
659 
660  //=== VK_KHR_cooperative_matrix ===
662 
663  //=== VK_KHR_calibrated_timestamps ===
665 
667  };
668 
670  {
671  public:
673  {
674  //=== VK_VERSION_1_0 ===
675  vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr( vkGetDeviceProcAddr( device, "vkGetDeviceProcAddr" ) );
676  vkDestroyDevice = PFN_vkDestroyDevice( vkGetDeviceProcAddr( device, "vkDestroyDevice" ) );
677  vkGetDeviceQueue = PFN_vkGetDeviceQueue( vkGetDeviceProcAddr( device, "vkGetDeviceQueue" ) );
678  vkQueueSubmit = PFN_vkQueueSubmit( vkGetDeviceProcAddr( device, "vkQueueSubmit" ) );
679  vkQueueWaitIdle = PFN_vkQueueWaitIdle( vkGetDeviceProcAddr( device, "vkQueueWaitIdle" ) );
680  vkDeviceWaitIdle = PFN_vkDeviceWaitIdle( vkGetDeviceProcAddr( device, "vkDeviceWaitIdle" ) );
681  vkAllocateMemory = PFN_vkAllocateMemory( vkGetDeviceProcAddr( device, "vkAllocateMemory" ) );
682  vkFreeMemory = PFN_vkFreeMemory( vkGetDeviceProcAddr( device, "vkFreeMemory" ) );
683  vkMapMemory = PFN_vkMapMemory( vkGetDeviceProcAddr( device, "vkMapMemory" ) );
684  vkUnmapMemory = PFN_vkUnmapMemory( vkGetDeviceProcAddr( device, "vkUnmapMemory" ) );
685  vkFlushMappedMemoryRanges = PFN_vkFlushMappedMemoryRanges( vkGetDeviceProcAddr( device, "vkFlushMappedMemoryRanges" ) );
686  vkInvalidateMappedMemoryRanges = PFN_vkInvalidateMappedMemoryRanges( vkGetDeviceProcAddr( device, "vkInvalidateMappedMemoryRanges" ) );
687  vkGetDeviceMemoryCommitment = PFN_vkGetDeviceMemoryCommitment( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryCommitment" ) );
688  vkBindBufferMemory = PFN_vkBindBufferMemory( vkGetDeviceProcAddr( device, "vkBindBufferMemory" ) );
689  vkBindImageMemory = PFN_vkBindImageMemory( vkGetDeviceProcAddr( device, "vkBindImageMemory" ) );
690  vkGetBufferMemoryRequirements = PFN_vkGetBufferMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements" ) );
691  vkGetImageMemoryRequirements = PFN_vkGetImageMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements" ) );
692  vkGetImageSparseMemoryRequirements = PFN_vkGetImageSparseMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements" ) );
693  vkQueueBindSparse = PFN_vkQueueBindSparse( vkGetDeviceProcAddr( device, "vkQueueBindSparse" ) );
694  vkCreateFence = PFN_vkCreateFence( vkGetDeviceProcAddr( device, "vkCreateFence" ) );
695  vkDestroyFence = PFN_vkDestroyFence( vkGetDeviceProcAddr( device, "vkDestroyFence" ) );
696  vkResetFences = PFN_vkResetFences( vkGetDeviceProcAddr( device, "vkResetFences" ) );
697  vkGetFenceStatus = PFN_vkGetFenceStatus( vkGetDeviceProcAddr( device, "vkGetFenceStatus" ) );
698  vkWaitForFences = PFN_vkWaitForFences( vkGetDeviceProcAddr( device, "vkWaitForFences" ) );
699  vkCreateSemaphore = PFN_vkCreateSemaphore( vkGetDeviceProcAddr( device, "vkCreateSemaphore" ) );
700  vkDestroySemaphore = PFN_vkDestroySemaphore( vkGetDeviceProcAddr( device, "vkDestroySemaphore" ) );
701  vkCreateEvent = PFN_vkCreateEvent( vkGetDeviceProcAddr( device, "vkCreateEvent" ) );
702  vkDestroyEvent = PFN_vkDestroyEvent( vkGetDeviceProcAddr( device, "vkDestroyEvent" ) );
703  vkGetEventStatus = PFN_vkGetEventStatus( vkGetDeviceProcAddr( device, "vkGetEventStatus" ) );
704  vkSetEvent = PFN_vkSetEvent( vkGetDeviceProcAddr( device, "vkSetEvent" ) );
705  vkResetEvent = PFN_vkResetEvent( vkGetDeviceProcAddr( device, "vkResetEvent" ) );
706  vkCreateQueryPool = PFN_vkCreateQueryPool( vkGetDeviceProcAddr( device, "vkCreateQueryPool" ) );
707  vkDestroyQueryPool = PFN_vkDestroyQueryPool( vkGetDeviceProcAddr( device, "vkDestroyQueryPool" ) );
708  vkGetQueryPoolResults = PFN_vkGetQueryPoolResults( vkGetDeviceProcAddr( device, "vkGetQueryPoolResults" ) );
709  vkCreateBuffer = PFN_vkCreateBuffer( vkGetDeviceProcAddr( device, "vkCreateBuffer" ) );
710  vkDestroyBuffer = PFN_vkDestroyBuffer( vkGetDeviceProcAddr( device, "vkDestroyBuffer" ) );
711  vkCreateBufferView = PFN_vkCreateBufferView( vkGetDeviceProcAddr( device, "vkCreateBufferView" ) );
712  vkDestroyBufferView = PFN_vkDestroyBufferView( vkGetDeviceProcAddr( device, "vkDestroyBufferView" ) );
713  vkCreateImage = PFN_vkCreateImage( vkGetDeviceProcAddr( device, "vkCreateImage" ) );
714  vkDestroyImage = PFN_vkDestroyImage( vkGetDeviceProcAddr( device, "vkDestroyImage" ) );
715  vkGetImageSubresourceLayout = PFN_vkGetImageSubresourceLayout( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout" ) );
716  vkCreateImageView = PFN_vkCreateImageView( vkGetDeviceProcAddr( device, "vkCreateImageView" ) );
717  vkDestroyImageView = PFN_vkDestroyImageView( vkGetDeviceProcAddr( device, "vkDestroyImageView" ) );
718  vkCreateShaderModule = PFN_vkCreateShaderModule( vkGetDeviceProcAddr( device, "vkCreateShaderModule" ) );
719  vkDestroyShaderModule = PFN_vkDestroyShaderModule( vkGetDeviceProcAddr( device, "vkDestroyShaderModule" ) );
720  vkCreatePipelineCache = PFN_vkCreatePipelineCache( vkGetDeviceProcAddr( device, "vkCreatePipelineCache" ) );
721  vkDestroyPipelineCache = PFN_vkDestroyPipelineCache( vkGetDeviceProcAddr( device, "vkDestroyPipelineCache" ) );
722  vkGetPipelineCacheData = PFN_vkGetPipelineCacheData( vkGetDeviceProcAddr( device, "vkGetPipelineCacheData" ) );
723  vkMergePipelineCaches = PFN_vkMergePipelineCaches( vkGetDeviceProcAddr( device, "vkMergePipelineCaches" ) );
724  vkCreateGraphicsPipelines = PFN_vkCreateGraphicsPipelines( vkGetDeviceProcAddr( device, "vkCreateGraphicsPipelines" ) );
725  vkCreateComputePipelines = PFN_vkCreateComputePipelines( vkGetDeviceProcAddr( device, "vkCreateComputePipelines" ) );
726  vkDestroyPipeline = PFN_vkDestroyPipeline( vkGetDeviceProcAddr( device, "vkDestroyPipeline" ) );
727  vkCreatePipelineLayout = PFN_vkCreatePipelineLayout( vkGetDeviceProcAddr( device, "vkCreatePipelineLayout" ) );
728  vkDestroyPipelineLayout = PFN_vkDestroyPipelineLayout( vkGetDeviceProcAddr( device, "vkDestroyPipelineLayout" ) );
729  vkCreateSampler = PFN_vkCreateSampler( vkGetDeviceProcAddr( device, "vkCreateSampler" ) );
730  vkDestroySampler = PFN_vkDestroySampler( vkGetDeviceProcAddr( device, "vkDestroySampler" ) );
731  vkCreateDescriptorSetLayout = PFN_vkCreateDescriptorSetLayout( vkGetDeviceProcAddr( device, "vkCreateDescriptorSetLayout" ) );
732  vkDestroyDescriptorSetLayout = PFN_vkDestroyDescriptorSetLayout( vkGetDeviceProcAddr( device, "vkDestroyDescriptorSetLayout" ) );
733  vkCreateDescriptorPool = PFN_vkCreateDescriptorPool( vkGetDeviceProcAddr( device, "vkCreateDescriptorPool" ) );
734  vkDestroyDescriptorPool = PFN_vkDestroyDescriptorPool( vkGetDeviceProcAddr( device, "vkDestroyDescriptorPool" ) );
735  vkResetDescriptorPool = PFN_vkResetDescriptorPool( vkGetDeviceProcAddr( device, "vkResetDescriptorPool" ) );
736  vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets( vkGetDeviceProcAddr( device, "vkAllocateDescriptorSets" ) );
737  vkFreeDescriptorSets = PFN_vkFreeDescriptorSets( vkGetDeviceProcAddr( device, "vkFreeDescriptorSets" ) );
738  vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSets" ) );
739  vkCreateFramebuffer = PFN_vkCreateFramebuffer( vkGetDeviceProcAddr( device, "vkCreateFramebuffer" ) );
740  vkDestroyFramebuffer = PFN_vkDestroyFramebuffer( vkGetDeviceProcAddr( device, "vkDestroyFramebuffer" ) );
741  vkCreateRenderPass = PFN_vkCreateRenderPass( vkGetDeviceProcAddr( device, "vkCreateRenderPass" ) );
742  vkDestroyRenderPass = PFN_vkDestroyRenderPass( vkGetDeviceProcAddr( device, "vkDestroyRenderPass" ) );
743  vkGetRenderAreaGranularity = PFN_vkGetRenderAreaGranularity( vkGetDeviceProcAddr( device, "vkGetRenderAreaGranularity" ) );
744  vkCreateCommandPool = PFN_vkCreateCommandPool( vkGetDeviceProcAddr( device, "vkCreateCommandPool" ) );
745  vkDestroyCommandPool = PFN_vkDestroyCommandPool( vkGetDeviceProcAddr( device, "vkDestroyCommandPool" ) );
746  vkResetCommandPool = PFN_vkResetCommandPool( vkGetDeviceProcAddr( device, "vkResetCommandPool" ) );
747  vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers( vkGetDeviceProcAddr( device, "vkAllocateCommandBuffers" ) );
748  vkFreeCommandBuffers = PFN_vkFreeCommandBuffers( vkGetDeviceProcAddr( device, "vkFreeCommandBuffers" ) );
749  vkBeginCommandBuffer = PFN_vkBeginCommandBuffer( vkGetDeviceProcAddr( device, "vkBeginCommandBuffer" ) );
750  vkEndCommandBuffer = PFN_vkEndCommandBuffer( vkGetDeviceProcAddr( device, "vkEndCommandBuffer" ) );
751  vkResetCommandBuffer = PFN_vkResetCommandBuffer( vkGetDeviceProcAddr( device, "vkResetCommandBuffer" ) );
752  vkCmdBindPipeline = PFN_vkCmdBindPipeline( vkGetDeviceProcAddr( device, "vkCmdBindPipeline" ) );
753  vkCmdSetViewport = PFN_vkCmdSetViewport( vkGetDeviceProcAddr( device, "vkCmdSetViewport" ) );
754  vkCmdSetScissor = PFN_vkCmdSetScissor( vkGetDeviceProcAddr( device, "vkCmdSetScissor" ) );
755  vkCmdSetLineWidth = PFN_vkCmdSetLineWidth( vkGetDeviceProcAddr( device, "vkCmdSetLineWidth" ) );
756  vkCmdSetDepthBias = PFN_vkCmdSetDepthBias( vkGetDeviceProcAddr( device, "vkCmdSetDepthBias" ) );
757  vkCmdSetBlendConstants = PFN_vkCmdSetBlendConstants( vkGetDeviceProcAddr( device, "vkCmdSetBlendConstants" ) );
758  vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds( vkGetDeviceProcAddr( device, "vkCmdSetDepthBounds" ) );
759  vkCmdSetStencilCompareMask = PFN_vkCmdSetStencilCompareMask( vkGetDeviceProcAddr( device, "vkCmdSetStencilCompareMask" ) );
760  vkCmdSetStencilWriteMask = PFN_vkCmdSetStencilWriteMask( vkGetDeviceProcAddr( device, "vkCmdSetStencilWriteMask" ) );
761  vkCmdSetStencilReference = PFN_vkCmdSetStencilReference( vkGetDeviceProcAddr( device, "vkCmdSetStencilReference" ) );
762  vkCmdBindDescriptorSets = PFN_vkCmdBindDescriptorSets( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorSets" ) );
763  vkCmdBindIndexBuffer = PFN_vkCmdBindIndexBuffer( vkGetDeviceProcAddr( device, "vkCmdBindIndexBuffer" ) );
764  vkCmdBindVertexBuffers = PFN_vkCmdBindVertexBuffers( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers" ) );
765  vkCmdDraw = PFN_vkCmdDraw( vkGetDeviceProcAddr( device, "vkCmdDraw" ) );
766  vkCmdDrawIndexed = PFN_vkCmdDrawIndexed( vkGetDeviceProcAddr( device, "vkCmdDrawIndexed" ) );
767  vkCmdDrawIndirect = PFN_vkCmdDrawIndirect( vkGetDeviceProcAddr( device, "vkCmdDrawIndirect" ) );
768  vkCmdDrawIndexedIndirect = PFN_vkCmdDrawIndexedIndirect( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirect" ) );
769  vkCmdDispatch = PFN_vkCmdDispatch( vkGetDeviceProcAddr( device, "vkCmdDispatch" ) );
770  vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect( vkGetDeviceProcAddr( device, "vkCmdDispatchIndirect" ) );
771  vkCmdCopyBuffer = PFN_vkCmdCopyBuffer( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer" ) );
772  vkCmdCopyImage = PFN_vkCmdCopyImage( vkGetDeviceProcAddr( device, "vkCmdCopyImage" ) );
773  vkCmdBlitImage = PFN_vkCmdBlitImage( vkGetDeviceProcAddr( device, "vkCmdBlitImage" ) );
774  vkCmdCopyBufferToImage = PFN_vkCmdCopyBufferToImage( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage" ) );
775  vkCmdCopyImageToBuffer = PFN_vkCmdCopyImageToBuffer( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer" ) );
776  vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer( vkGetDeviceProcAddr( device, "vkCmdUpdateBuffer" ) );
777  vkCmdFillBuffer = PFN_vkCmdFillBuffer( vkGetDeviceProcAddr( device, "vkCmdFillBuffer" ) );
778  vkCmdClearColorImage = PFN_vkCmdClearColorImage( vkGetDeviceProcAddr( device, "vkCmdClearColorImage" ) );
779  vkCmdClearDepthStencilImage = PFN_vkCmdClearDepthStencilImage( vkGetDeviceProcAddr( device, "vkCmdClearDepthStencilImage" ) );
780  vkCmdClearAttachments = PFN_vkCmdClearAttachments( vkGetDeviceProcAddr( device, "vkCmdClearAttachments" ) );
781  vkCmdResolveImage = PFN_vkCmdResolveImage( vkGetDeviceProcAddr( device, "vkCmdResolveImage" ) );
782  vkCmdSetEvent = PFN_vkCmdSetEvent( vkGetDeviceProcAddr( device, "vkCmdSetEvent" ) );
783  vkCmdResetEvent = PFN_vkCmdResetEvent( vkGetDeviceProcAddr( device, "vkCmdResetEvent" ) );
784  vkCmdWaitEvents = PFN_vkCmdWaitEvents( vkGetDeviceProcAddr( device, "vkCmdWaitEvents" ) );
785  vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier" ) );
786  vkCmdBeginQuery = PFN_vkCmdBeginQuery( vkGetDeviceProcAddr( device, "vkCmdBeginQuery" ) );
787  vkCmdEndQuery = PFN_vkCmdEndQuery( vkGetDeviceProcAddr( device, "vkCmdEndQuery" ) );
788  vkCmdResetQueryPool = PFN_vkCmdResetQueryPool( vkGetDeviceProcAddr( device, "vkCmdResetQueryPool" ) );
789  vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp" ) );
790  vkCmdCopyQueryPoolResults = PFN_vkCmdCopyQueryPoolResults( vkGetDeviceProcAddr( device, "vkCmdCopyQueryPoolResults" ) );
791  vkCmdPushConstants = PFN_vkCmdPushConstants( vkGetDeviceProcAddr( device, "vkCmdPushConstants" ) );
792  vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass" ) );
793  vkCmdNextSubpass = PFN_vkCmdNextSubpass( vkGetDeviceProcAddr( device, "vkCmdNextSubpass" ) );
794  vkCmdEndRenderPass = PFN_vkCmdEndRenderPass( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass" ) );
795  vkCmdExecuteCommands = PFN_vkCmdExecuteCommands( vkGetDeviceProcAddr( device, "vkCmdExecuteCommands" ) );
796 
797  //=== VK_VERSION_1_1 ===
798  vkBindBufferMemory2 = PFN_vkBindBufferMemory2( vkGetDeviceProcAddr( device, "vkBindBufferMemory2" ) );
799  vkBindImageMemory2 = PFN_vkBindImageMemory2( vkGetDeviceProcAddr( device, "vkBindImageMemory2" ) );
800  vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeatures" ) );
801  vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask( vkGetDeviceProcAddr( device, "vkCmdSetDeviceMask" ) );
802  vkCmdDispatchBase = PFN_vkCmdDispatchBase( vkGetDeviceProcAddr( device, "vkCmdDispatchBase" ) );
803  vkGetImageMemoryRequirements2 = PFN_vkGetImageMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements2" ) );
804  vkGetBufferMemoryRequirements2 = PFN_vkGetBufferMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements2" ) );
805  vkGetImageSparseMemoryRequirements2 = PFN_vkGetImageSparseMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements2" ) );
806  vkTrimCommandPool = PFN_vkTrimCommandPool( vkGetDeviceProcAddr( device, "vkTrimCommandPool" ) );
807  vkGetDeviceQueue2 = PFN_vkGetDeviceQueue2( vkGetDeviceProcAddr( device, "vkGetDeviceQueue2" ) );
808  vkCreateSamplerYcbcrConversion = PFN_vkCreateSamplerYcbcrConversion( vkGetDeviceProcAddr( device, "vkCreateSamplerYcbcrConversion" ) );
809  vkDestroySamplerYcbcrConversion = PFN_vkDestroySamplerYcbcrConversion( vkGetDeviceProcAddr( device, "vkDestroySamplerYcbcrConversion" ) );
810  vkCreateDescriptorUpdateTemplate = PFN_vkCreateDescriptorUpdateTemplate( vkGetDeviceProcAddr( device, "vkCreateDescriptorUpdateTemplate" ) );
811  vkDestroyDescriptorUpdateTemplate = PFN_vkDestroyDescriptorUpdateTemplate( vkGetDeviceProcAddr( device, "vkDestroyDescriptorUpdateTemplate" ) );
812  vkUpdateDescriptorSetWithTemplate = PFN_vkUpdateDescriptorSetWithTemplate( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSetWithTemplate" ) );
813  vkGetDescriptorSetLayoutSupport = PFN_vkGetDescriptorSetLayoutSupport( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSupport" ) );
814 
815  //=== VK_VERSION_1_2 ===
816  vkCmdDrawIndirectCount = PFN_vkCmdDrawIndirectCount( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCount" ) );
817  vkCmdDrawIndexedIndirectCount = PFN_vkCmdDrawIndexedIndirectCount( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCount" ) );
818  vkCreateRenderPass2 = PFN_vkCreateRenderPass2( vkGetDeviceProcAddr( device, "vkCreateRenderPass2" ) );
819  vkCmdBeginRenderPass2 = PFN_vkCmdBeginRenderPass2( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass2" ) );
820  vkCmdNextSubpass2 = PFN_vkCmdNextSubpass2( vkGetDeviceProcAddr( device, "vkCmdNextSubpass2" ) );
821  vkCmdEndRenderPass2 = PFN_vkCmdEndRenderPass2( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass2" ) );
822  vkResetQueryPool = PFN_vkResetQueryPool( vkGetDeviceProcAddr( device, "vkResetQueryPool" ) );
823  vkGetSemaphoreCounterValue = PFN_vkGetSemaphoreCounterValue( vkGetDeviceProcAddr( device, "vkGetSemaphoreCounterValue" ) );
824  vkWaitSemaphores = PFN_vkWaitSemaphores( vkGetDeviceProcAddr( device, "vkWaitSemaphores" ) );
825  vkSignalSemaphore = PFN_vkSignalSemaphore( vkGetDeviceProcAddr( device, "vkSignalSemaphore" ) );
826  vkGetBufferDeviceAddress = PFN_vkGetBufferDeviceAddress( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddress" ) );
827  vkGetBufferOpaqueCaptureAddress = PFN_vkGetBufferOpaqueCaptureAddress( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureAddress" ) );
829  PFN_vkGetDeviceMemoryOpaqueCaptureAddress( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryOpaqueCaptureAddress" ) );
830 
831  //=== VK_VERSION_1_3 ===
832  vkCreatePrivateDataSlot = PFN_vkCreatePrivateDataSlot( vkGetDeviceProcAddr( device, "vkCreatePrivateDataSlot" ) );
833  vkDestroyPrivateDataSlot = PFN_vkDestroyPrivateDataSlot( vkGetDeviceProcAddr( device, "vkDestroyPrivateDataSlot" ) );
834  vkSetPrivateData = PFN_vkSetPrivateData( vkGetDeviceProcAddr( device, "vkSetPrivateData" ) );
835  vkGetPrivateData = PFN_vkGetPrivateData( vkGetDeviceProcAddr( device, "vkGetPrivateData" ) );
836  vkCmdSetEvent2 = PFN_vkCmdSetEvent2( vkGetDeviceProcAddr( device, "vkCmdSetEvent2" ) );
837  vkCmdResetEvent2 = PFN_vkCmdResetEvent2( vkGetDeviceProcAddr( device, "vkCmdResetEvent2" ) );
838  vkCmdWaitEvents2 = PFN_vkCmdWaitEvents2( vkGetDeviceProcAddr( device, "vkCmdWaitEvents2" ) );
839  vkCmdPipelineBarrier2 = PFN_vkCmdPipelineBarrier2( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier2" ) );
840  vkCmdWriteTimestamp2 = PFN_vkCmdWriteTimestamp2( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp2" ) );
841  vkQueueSubmit2 = PFN_vkQueueSubmit2( vkGetDeviceProcAddr( device, "vkQueueSubmit2" ) );
842  vkCmdCopyBuffer2 = PFN_vkCmdCopyBuffer2( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer2" ) );
843  vkCmdCopyImage2 = PFN_vkCmdCopyImage2( vkGetDeviceProcAddr( device, "vkCmdCopyImage2" ) );
844  vkCmdCopyBufferToImage2 = PFN_vkCmdCopyBufferToImage2( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage2" ) );
845  vkCmdCopyImageToBuffer2 = PFN_vkCmdCopyImageToBuffer2( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer2" ) );
846  vkCmdBlitImage2 = PFN_vkCmdBlitImage2( vkGetDeviceProcAddr( device, "vkCmdBlitImage2" ) );
847  vkCmdResolveImage2 = PFN_vkCmdResolveImage2( vkGetDeviceProcAddr( device, "vkCmdResolveImage2" ) );
848  vkCmdBeginRendering = PFN_vkCmdBeginRendering( vkGetDeviceProcAddr( device, "vkCmdBeginRendering" ) );
849  vkCmdEndRendering = PFN_vkCmdEndRendering( vkGetDeviceProcAddr( device, "vkCmdEndRendering" ) );
850  vkCmdSetCullMode = PFN_vkCmdSetCullMode( vkGetDeviceProcAddr( device, "vkCmdSetCullMode" ) );
851  vkCmdSetFrontFace = PFN_vkCmdSetFrontFace( vkGetDeviceProcAddr( device, "vkCmdSetFrontFace" ) );
852  vkCmdSetPrimitiveTopology = PFN_vkCmdSetPrimitiveTopology( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveTopology" ) );
853  vkCmdSetViewportWithCount = PFN_vkCmdSetViewportWithCount( vkGetDeviceProcAddr( device, "vkCmdSetViewportWithCount" ) );
854  vkCmdSetScissorWithCount = PFN_vkCmdSetScissorWithCount( vkGetDeviceProcAddr( device, "vkCmdSetScissorWithCount" ) );
855  vkCmdBindVertexBuffers2 = PFN_vkCmdBindVertexBuffers2( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers2" ) );
856  vkCmdSetDepthTestEnable = PFN_vkCmdSetDepthTestEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthTestEnable" ) );
857  vkCmdSetDepthWriteEnable = PFN_vkCmdSetDepthWriteEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthWriteEnable" ) );
858  vkCmdSetDepthCompareOp = PFN_vkCmdSetDepthCompareOp( vkGetDeviceProcAddr( device, "vkCmdSetDepthCompareOp" ) );
859  vkCmdSetDepthBoundsTestEnable = PFN_vkCmdSetDepthBoundsTestEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthBoundsTestEnable" ) );
860  vkCmdSetStencilTestEnable = PFN_vkCmdSetStencilTestEnable( vkGetDeviceProcAddr( device, "vkCmdSetStencilTestEnable" ) );
861  vkCmdSetStencilOp = PFN_vkCmdSetStencilOp( vkGetDeviceProcAddr( device, "vkCmdSetStencilOp" ) );
862  vkCmdSetRasterizerDiscardEnable = PFN_vkCmdSetRasterizerDiscardEnable( vkGetDeviceProcAddr( device, "vkCmdSetRasterizerDiscardEnable" ) );
863  vkCmdSetDepthBiasEnable = PFN_vkCmdSetDepthBiasEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthBiasEnable" ) );
864  vkCmdSetPrimitiveRestartEnable = PFN_vkCmdSetPrimitiveRestartEnable( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveRestartEnable" ) );
865  vkGetDeviceBufferMemoryRequirements = PFN_vkGetDeviceBufferMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetDeviceBufferMemoryRequirements" ) );
866  vkGetDeviceImageMemoryRequirements = PFN_vkGetDeviceImageMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetDeviceImageMemoryRequirements" ) );
868  PFN_vkGetDeviceImageSparseMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetDeviceImageSparseMemoryRequirements" ) );
869 
870  //=== VK_KHR_swapchain ===
871  vkCreateSwapchainKHR = PFN_vkCreateSwapchainKHR( vkGetDeviceProcAddr( device, "vkCreateSwapchainKHR" ) );
872  vkDestroySwapchainKHR = PFN_vkDestroySwapchainKHR( vkGetDeviceProcAddr( device, "vkDestroySwapchainKHR" ) );
873  vkGetSwapchainImagesKHR = PFN_vkGetSwapchainImagesKHR( vkGetDeviceProcAddr( device, "vkGetSwapchainImagesKHR" ) );
874  vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR( vkGetDeviceProcAddr( device, "vkAcquireNextImageKHR" ) );
875  vkQueuePresentKHR = PFN_vkQueuePresentKHR( vkGetDeviceProcAddr( device, "vkQueuePresentKHR" ) );
877  PFN_vkGetDeviceGroupPresentCapabilitiesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPresentCapabilitiesKHR" ) );
879  PFN_vkGetDeviceGroupSurfacePresentModesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModesKHR" ) );
880  vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR( vkGetDeviceProcAddr( device, "vkAcquireNextImage2KHR" ) );
881 
882  //=== VK_KHR_display_swapchain ===
883  vkCreateSharedSwapchainsKHR = PFN_vkCreateSharedSwapchainsKHR( vkGetDeviceProcAddr( device, "vkCreateSharedSwapchainsKHR" ) );
884 
885  //=== VK_EXT_debug_marker ===
886  vkDebugMarkerSetObjectTagEXT = PFN_vkDebugMarkerSetObjectTagEXT( vkGetDeviceProcAddr( device, "vkDebugMarkerSetObjectTagEXT" ) );
887  vkDebugMarkerSetObjectNameEXT = PFN_vkDebugMarkerSetObjectNameEXT( vkGetDeviceProcAddr( device, "vkDebugMarkerSetObjectNameEXT" ) );
888  vkCmdDebugMarkerBeginEXT = PFN_vkCmdDebugMarkerBeginEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerBeginEXT" ) );
889  vkCmdDebugMarkerEndEXT = PFN_vkCmdDebugMarkerEndEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerEndEXT" ) );
890  vkCmdDebugMarkerInsertEXT = PFN_vkCmdDebugMarkerInsertEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerInsertEXT" ) );
891 
892  //=== VK_KHR_video_queue ===
893  vkCreateVideoSessionKHR = PFN_vkCreateVideoSessionKHR( vkGetDeviceProcAddr( device, "vkCreateVideoSessionKHR" ) );
894  vkDestroyVideoSessionKHR = PFN_vkDestroyVideoSessionKHR( vkGetDeviceProcAddr( device, "vkDestroyVideoSessionKHR" ) );
896  PFN_vkGetVideoSessionMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetVideoSessionMemoryRequirementsKHR" ) );
897  vkBindVideoSessionMemoryKHR = PFN_vkBindVideoSessionMemoryKHR( vkGetDeviceProcAddr( device, "vkBindVideoSessionMemoryKHR" ) );
898  vkCreateVideoSessionParametersKHR = PFN_vkCreateVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkCreateVideoSessionParametersKHR" ) );
899  vkUpdateVideoSessionParametersKHR = PFN_vkUpdateVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkUpdateVideoSessionParametersKHR" ) );
900  vkDestroyVideoSessionParametersKHR = PFN_vkDestroyVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkDestroyVideoSessionParametersKHR" ) );
901  vkCmdBeginVideoCodingKHR = PFN_vkCmdBeginVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdBeginVideoCodingKHR" ) );
902  vkCmdEndVideoCodingKHR = PFN_vkCmdEndVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdEndVideoCodingKHR" ) );
903  vkCmdControlVideoCodingKHR = PFN_vkCmdControlVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdControlVideoCodingKHR" ) );
904 
905  //=== VK_KHR_video_decode_queue ===
906  vkCmdDecodeVideoKHR = PFN_vkCmdDecodeVideoKHR( vkGetDeviceProcAddr( device, "vkCmdDecodeVideoKHR" ) );
907 
908  //=== VK_EXT_transform_feedback ===
910  PFN_vkCmdBindTransformFeedbackBuffersEXT( vkGetDeviceProcAddr( device, "vkCmdBindTransformFeedbackBuffersEXT" ) );
911  vkCmdBeginTransformFeedbackEXT = PFN_vkCmdBeginTransformFeedbackEXT( vkGetDeviceProcAddr( device, "vkCmdBeginTransformFeedbackEXT" ) );
912  vkCmdEndTransformFeedbackEXT = PFN_vkCmdEndTransformFeedbackEXT( vkGetDeviceProcAddr( device, "vkCmdEndTransformFeedbackEXT" ) );
913  vkCmdBeginQueryIndexedEXT = PFN_vkCmdBeginQueryIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdBeginQueryIndexedEXT" ) );
914  vkCmdEndQueryIndexedEXT = PFN_vkCmdEndQueryIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdEndQueryIndexedEXT" ) );
915  vkCmdDrawIndirectByteCountEXT = PFN_vkCmdDrawIndirectByteCountEXT( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectByteCountEXT" ) );
916 
917  //=== VK_NVX_binary_import ===
918  vkCreateCuModuleNVX = PFN_vkCreateCuModuleNVX( vkGetDeviceProcAddr( device, "vkCreateCuModuleNVX" ) );
919  vkCreateCuFunctionNVX = PFN_vkCreateCuFunctionNVX( vkGetDeviceProcAddr( device, "vkCreateCuFunctionNVX" ) );
920  vkDestroyCuModuleNVX = PFN_vkDestroyCuModuleNVX( vkGetDeviceProcAddr( device, "vkDestroyCuModuleNVX" ) );
921  vkDestroyCuFunctionNVX = PFN_vkDestroyCuFunctionNVX( vkGetDeviceProcAddr( device, "vkDestroyCuFunctionNVX" ) );
922  vkCmdCuLaunchKernelNVX = PFN_vkCmdCuLaunchKernelNVX( vkGetDeviceProcAddr( device, "vkCmdCuLaunchKernelNVX" ) );
923 
924  //=== VK_NVX_image_view_handle ===
925  vkGetImageViewHandleNVX = PFN_vkGetImageViewHandleNVX( vkGetDeviceProcAddr( device, "vkGetImageViewHandleNVX" ) );
926  vkGetImageViewAddressNVX = PFN_vkGetImageViewAddressNVX( vkGetDeviceProcAddr( device, "vkGetImageViewAddressNVX" ) );
927 
928  //=== VK_AMD_draw_indirect_count ===
929  vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountAMD" ) );
930  if ( !vkCmdDrawIndirectCount )
932  vkCmdDrawIndexedIndirectCountAMD = PFN_vkCmdDrawIndexedIndirectCountAMD( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCountAMD" ) );
935 
936  //=== VK_AMD_shader_info ===
937  vkGetShaderInfoAMD = PFN_vkGetShaderInfoAMD( vkGetDeviceProcAddr( device, "vkGetShaderInfoAMD" ) );
938 
939  //=== VK_KHR_dynamic_rendering ===
940  vkCmdBeginRenderingKHR = PFN_vkCmdBeginRenderingKHR( vkGetDeviceProcAddr( device, "vkCmdBeginRenderingKHR" ) );
941  if ( !vkCmdBeginRendering )
943  vkCmdEndRenderingKHR = PFN_vkCmdEndRenderingKHR( vkGetDeviceProcAddr( device, "vkCmdEndRenderingKHR" ) );
944  if ( !vkCmdEndRendering )
946 
947 # if defined( VK_USE_PLATFORM_WIN32_KHR )
948  //=== VK_NV_external_memory_win32 ===
949  vkGetMemoryWin32HandleNV = PFN_vkGetMemoryWin32HandleNV( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleNV" ) );
950 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
951 
952  //=== VK_KHR_device_group ===
954  PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeaturesKHR" ) );
957  vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR( vkGetDeviceProcAddr( device, "vkCmdSetDeviceMaskKHR" ) );
958  if ( !vkCmdSetDeviceMask )
960  vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR( vkGetDeviceProcAddr( device, "vkCmdDispatchBaseKHR" ) );
961  if ( !vkCmdDispatchBase )
963 
964  //=== VK_KHR_maintenance1 ===
965  vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR( vkGetDeviceProcAddr( device, "vkTrimCommandPoolKHR" ) );
966  if ( !vkTrimCommandPool )
968 
969 # if defined( VK_USE_PLATFORM_WIN32_KHR )
970  //=== VK_KHR_external_memory_win32 ===
971  vkGetMemoryWin32HandleKHR = PFN_vkGetMemoryWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleKHR" ) );
972  vkGetMemoryWin32HandlePropertiesKHR = PFN_vkGetMemoryWin32HandlePropertiesKHR( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandlePropertiesKHR" ) );
973 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
974 
975  //=== VK_KHR_external_memory_fd ===
976  vkGetMemoryFdKHR = PFN_vkGetMemoryFdKHR( vkGetDeviceProcAddr( device, "vkGetMemoryFdKHR" ) );
977  vkGetMemoryFdPropertiesKHR = PFN_vkGetMemoryFdPropertiesKHR( vkGetDeviceProcAddr( device, "vkGetMemoryFdPropertiesKHR" ) );
978 
979 # if defined( VK_USE_PLATFORM_WIN32_KHR )
980  //=== VK_KHR_external_semaphore_win32 ===
981  vkImportSemaphoreWin32HandleKHR = PFN_vkImportSemaphoreWin32HandleKHR( vkGetDeviceProcAddr( device, "vkImportSemaphoreWin32HandleKHR" ) );
982  vkGetSemaphoreWin32HandleKHR = PFN_vkGetSemaphoreWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreWin32HandleKHR" ) );
983 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
984 
985  //=== VK_KHR_external_semaphore_fd ===
986  vkImportSemaphoreFdKHR = PFN_vkImportSemaphoreFdKHR( vkGetDeviceProcAddr( device, "vkImportSemaphoreFdKHR" ) );
987  vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreFdKHR" ) );
988 
989  //=== VK_KHR_push_descriptor ===
990  vkCmdPushDescriptorSetKHR = PFN_vkCmdPushDescriptorSetKHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetKHR" ) );
992  PFN_vkCmdPushDescriptorSetWithTemplateKHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetWithTemplateKHR" ) );
993 
994  //=== VK_EXT_conditional_rendering ===
995  vkCmdBeginConditionalRenderingEXT = PFN_vkCmdBeginConditionalRenderingEXT( vkGetDeviceProcAddr( device, "vkCmdBeginConditionalRenderingEXT" ) );
996  vkCmdEndConditionalRenderingEXT = PFN_vkCmdEndConditionalRenderingEXT( vkGetDeviceProcAddr( device, "vkCmdEndConditionalRenderingEXT" ) );
997 
998  //=== VK_KHR_descriptor_update_template ===
999  vkCreateDescriptorUpdateTemplateKHR = PFN_vkCreateDescriptorUpdateTemplateKHR( vkGetDeviceProcAddr( device, "vkCreateDescriptorUpdateTemplateKHR" ) );
1003  PFN_vkDestroyDescriptorUpdateTemplateKHR( vkGetDeviceProcAddr( device, "vkDestroyDescriptorUpdateTemplateKHR" ) );
1007  PFN_vkUpdateDescriptorSetWithTemplateKHR( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSetWithTemplateKHR" ) );
1010 
1011  //=== VK_NV_clip_space_w_scaling ===
1012  vkCmdSetViewportWScalingNV = PFN_vkCmdSetViewportWScalingNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportWScalingNV" ) );
1013 
1014  //=== VK_EXT_display_control ===
1015  vkDisplayPowerControlEXT = PFN_vkDisplayPowerControlEXT( vkGetDeviceProcAddr( device, "vkDisplayPowerControlEXT" ) );
1016  vkRegisterDeviceEventEXT = PFN_vkRegisterDeviceEventEXT( vkGetDeviceProcAddr( device, "vkRegisterDeviceEventEXT" ) );
1017  vkRegisterDisplayEventEXT = PFN_vkRegisterDisplayEventEXT( vkGetDeviceProcAddr( device, "vkRegisterDisplayEventEXT" ) );
1018  vkGetSwapchainCounterEXT = PFN_vkGetSwapchainCounterEXT( vkGetDeviceProcAddr( device, "vkGetSwapchainCounterEXT" ) );
1019 
1020  //=== VK_GOOGLE_display_timing ===
1021  vkGetRefreshCycleDurationGOOGLE = PFN_vkGetRefreshCycleDurationGOOGLE( vkGetDeviceProcAddr( device, "vkGetRefreshCycleDurationGOOGLE" ) );
1022  vkGetPastPresentationTimingGOOGLE = PFN_vkGetPastPresentationTimingGOOGLE( vkGetDeviceProcAddr( device, "vkGetPastPresentationTimingGOOGLE" ) );
1023 
1024  //=== VK_EXT_discard_rectangles ===
1025  vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleEXT" ) );
1026  vkCmdSetDiscardRectangleEnableEXT = PFN_vkCmdSetDiscardRectangleEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleEnableEXT" ) );
1027  vkCmdSetDiscardRectangleModeEXT = PFN_vkCmdSetDiscardRectangleModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleModeEXT" ) );
1028 
1029  //=== VK_EXT_hdr_metadata ===
1030  vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT( vkGetDeviceProcAddr( device, "vkSetHdrMetadataEXT" ) );
1031 
1032  //=== VK_KHR_create_renderpass2 ===
1033  vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCreateRenderPass2KHR" ) );
1034  if ( !vkCreateRenderPass2 )
1036  vkCmdBeginRenderPass2KHR = PFN_vkCmdBeginRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass2KHR" ) );
1037  if ( !vkCmdBeginRenderPass2 )
1039  vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2KHR( vkGetDeviceProcAddr( device, "vkCmdNextSubpass2KHR" ) );
1040  if ( !vkCmdNextSubpass2 )
1042  vkCmdEndRenderPass2KHR = PFN_vkCmdEndRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass2KHR" ) );
1043  if ( !vkCmdEndRenderPass2 )
1045 
1046  //=== VK_KHR_shared_presentable_image ===
1047  vkGetSwapchainStatusKHR = PFN_vkGetSwapchainStatusKHR( vkGetDeviceProcAddr( device, "vkGetSwapchainStatusKHR" ) );
1048 
1049 # if defined( VK_USE_PLATFORM_WIN32_KHR )
1050  //=== VK_KHR_external_fence_win32 ===
1051  vkImportFenceWin32HandleKHR = PFN_vkImportFenceWin32HandleKHR( vkGetDeviceProcAddr( device, "vkImportFenceWin32HandleKHR" ) );
1052  vkGetFenceWin32HandleKHR = PFN_vkGetFenceWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetFenceWin32HandleKHR" ) );
1053 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
1054 
1055  //=== VK_KHR_external_fence_fd ===
1056  vkImportFenceFdKHR = PFN_vkImportFenceFdKHR( vkGetDeviceProcAddr( device, "vkImportFenceFdKHR" ) );
1057  vkGetFenceFdKHR = PFN_vkGetFenceFdKHR( vkGetDeviceProcAddr( device, "vkGetFenceFdKHR" ) );
1058 
1059  //=== VK_KHR_performance_query ===
1060  vkAcquireProfilingLockKHR = PFN_vkAcquireProfilingLockKHR( vkGetDeviceProcAddr( device, "vkAcquireProfilingLockKHR" ) );
1061  vkReleaseProfilingLockKHR = PFN_vkReleaseProfilingLockKHR( vkGetDeviceProcAddr( device, "vkReleaseProfilingLockKHR" ) );
1062 
1063  //=== VK_EXT_debug_utils ===
1064  vkSetDebugUtilsObjectNameEXT = PFN_vkSetDebugUtilsObjectNameEXT( vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectNameEXT" ) );
1065  vkSetDebugUtilsObjectTagEXT = PFN_vkSetDebugUtilsObjectTagEXT( vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectTagEXT" ) );
1066  vkQueueBeginDebugUtilsLabelEXT = PFN_vkQueueBeginDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueBeginDebugUtilsLabelEXT" ) );
1067  vkQueueEndDebugUtilsLabelEXT = PFN_vkQueueEndDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueEndDebugUtilsLabelEXT" ) );
1068  vkQueueInsertDebugUtilsLabelEXT = PFN_vkQueueInsertDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueInsertDebugUtilsLabelEXT" ) );
1069  vkCmdBeginDebugUtilsLabelEXT = PFN_vkCmdBeginDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdBeginDebugUtilsLabelEXT" ) );
1070  vkCmdEndDebugUtilsLabelEXT = PFN_vkCmdEndDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdEndDebugUtilsLabelEXT" ) );
1071  vkCmdInsertDebugUtilsLabelEXT = PFN_vkCmdInsertDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdInsertDebugUtilsLabelEXT" ) );
1072 
1073 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
1074  //=== VK_ANDROID_external_memory_android_hardware_buffer ===
1075  vkGetAndroidHardwareBufferPropertiesANDROID =
1076  PFN_vkGetAndroidHardwareBufferPropertiesANDROID( vkGetDeviceProcAddr( device, "vkGetAndroidHardwareBufferPropertiesANDROID" ) );
1077  vkGetMemoryAndroidHardwareBufferANDROID =
1078  PFN_vkGetMemoryAndroidHardwareBufferANDROID( vkGetDeviceProcAddr( device, "vkGetMemoryAndroidHardwareBufferANDROID" ) );
1079 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
1080 
1081 # if defined( VK_ENABLE_BETA_EXTENSIONS )
1082  //=== VK_AMDX_shader_enqueue ===
1083  vkCreateExecutionGraphPipelinesAMDX = PFN_vkCreateExecutionGraphPipelinesAMDX( vkGetDeviceProcAddr( device, "vkCreateExecutionGraphPipelinesAMDX" ) );
1084  vkGetExecutionGraphPipelineScratchSizeAMDX =
1085  PFN_vkGetExecutionGraphPipelineScratchSizeAMDX( vkGetDeviceProcAddr( device, "vkGetExecutionGraphPipelineScratchSizeAMDX" ) );
1086  vkGetExecutionGraphPipelineNodeIndexAMDX =
1087  PFN_vkGetExecutionGraphPipelineNodeIndexAMDX( vkGetDeviceProcAddr( device, "vkGetExecutionGraphPipelineNodeIndexAMDX" ) );
1088  vkCmdInitializeGraphScratchMemoryAMDX =
1089  PFN_vkCmdInitializeGraphScratchMemoryAMDX( vkGetDeviceProcAddr( device, "vkCmdInitializeGraphScratchMemoryAMDX" ) );
1090  vkCmdDispatchGraphAMDX = PFN_vkCmdDispatchGraphAMDX( vkGetDeviceProcAddr( device, "vkCmdDispatchGraphAMDX" ) );
1091  vkCmdDispatchGraphIndirectAMDX = PFN_vkCmdDispatchGraphIndirectAMDX( vkGetDeviceProcAddr( device, "vkCmdDispatchGraphIndirectAMDX" ) );
1092  vkCmdDispatchGraphIndirectCountAMDX = PFN_vkCmdDispatchGraphIndirectCountAMDX( vkGetDeviceProcAddr( device, "vkCmdDispatchGraphIndirectCountAMDX" ) );
1093 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
1094 
1095  //=== VK_EXT_sample_locations ===
1096  vkCmdSetSampleLocationsEXT = PFN_vkCmdSetSampleLocationsEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleLocationsEXT" ) );
1097 
1098  //=== VK_KHR_get_memory_requirements2 ===
1099  vkGetImageMemoryRequirements2KHR = PFN_vkGetImageMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements2KHR" ) );
1102  vkGetBufferMemoryRequirements2KHR = PFN_vkGetBufferMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements2KHR" ) );
1106  PFN_vkGetImageSparseMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements2KHR" ) );
1109 
1110  //=== VK_KHR_acceleration_structure ===
1111  vkCreateAccelerationStructureKHR = PFN_vkCreateAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCreateAccelerationStructureKHR" ) );
1112  vkDestroyAccelerationStructureKHR = PFN_vkDestroyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkDestroyAccelerationStructureKHR" ) );
1113  vkCmdBuildAccelerationStructuresKHR = PFN_vkCmdBuildAccelerationStructuresKHR( vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructuresKHR" ) );
1115  PFN_vkCmdBuildAccelerationStructuresIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructuresIndirectKHR" ) );
1116  vkBuildAccelerationStructuresKHR = PFN_vkBuildAccelerationStructuresKHR( vkGetDeviceProcAddr( device, "vkBuildAccelerationStructuresKHR" ) );
1117  vkCopyAccelerationStructureKHR = PFN_vkCopyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCopyAccelerationStructureKHR" ) );
1119  PFN_vkCopyAccelerationStructureToMemoryKHR( vkGetDeviceProcAddr( device, "vkCopyAccelerationStructureToMemoryKHR" ) );
1121  PFN_vkCopyMemoryToAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCopyMemoryToAccelerationStructureKHR" ) );
1123  PFN_vkWriteAccelerationStructuresPropertiesKHR( vkGetDeviceProcAddr( device, "vkWriteAccelerationStructuresPropertiesKHR" ) );
1124  vkCmdCopyAccelerationStructureKHR = PFN_vkCmdCopyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureKHR" ) );
1126  PFN_vkCmdCopyAccelerationStructureToMemoryKHR( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureToMemoryKHR" ) );
1128  PFN_vkCmdCopyMemoryToAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToAccelerationStructureKHR" ) );
1130  PFN_vkGetAccelerationStructureDeviceAddressKHR( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureDeviceAddressKHR" ) );
1132  PFN_vkCmdWriteAccelerationStructuresPropertiesKHR( vkGetDeviceProcAddr( device, "vkCmdWriteAccelerationStructuresPropertiesKHR" ) );
1134  PFN_vkGetDeviceAccelerationStructureCompatibilityKHR( vkGetDeviceProcAddr( device, "vkGetDeviceAccelerationStructureCompatibilityKHR" ) );
1136  PFN_vkGetAccelerationStructureBuildSizesKHR( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureBuildSizesKHR" ) );
1137 
1138  //=== VK_KHR_ray_tracing_pipeline ===
1139  vkCmdTraceRaysKHR = PFN_vkCmdTraceRaysKHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysKHR" ) );
1140  vkCreateRayTracingPipelinesKHR = PFN_vkCreateRayTracingPipelinesKHR( vkGetDeviceProcAddr( device, "vkCreateRayTracingPipelinesKHR" ) );
1142  PFN_vkGetRayTracingShaderGroupHandlesKHR( vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupHandlesKHR" ) );
1144  PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( vkGetDeviceProcAddr( device, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR" ) );
1145  vkCmdTraceRaysIndirectKHR = PFN_vkCmdTraceRaysIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysIndirectKHR" ) );
1147  PFN_vkGetRayTracingShaderGroupStackSizeKHR( vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupStackSizeKHR" ) );
1149  PFN_vkCmdSetRayTracingPipelineStackSizeKHR( vkGetDeviceProcAddr( device, "vkCmdSetRayTracingPipelineStackSizeKHR" ) );
1150 
1151  //=== VK_KHR_sampler_ycbcr_conversion ===
1152  vkCreateSamplerYcbcrConversionKHR = PFN_vkCreateSamplerYcbcrConversionKHR( vkGetDeviceProcAddr( device, "vkCreateSamplerYcbcrConversionKHR" ) );
1155  vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversionKHR( vkGetDeviceProcAddr( device, "vkDestroySamplerYcbcrConversionKHR" ) );
1158 
1159  //=== VK_KHR_bind_memory2 ===
1160  vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR( vkGetDeviceProcAddr( device, "vkBindBufferMemory2KHR" ) );
1161  if ( !vkBindBufferMemory2 )
1163  vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR( vkGetDeviceProcAddr( device, "vkBindImageMemory2KHR" ) );
1164  if ( !vkBindImageMemory2 )
1166 
1167  //=== VK_EXT_image_drm_format_modifier ===
1169  PFN_vkGetImageDrmFormatModifierPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetImageDrmFormatModifierPropertiesEXT" ) );
1170 
1171  //=== VK_EXT_validation_cache ===
1172  vkCreateValidationCacheEXT = PFN_vkCreateValidationCacheEXT( vkGetDeviceProcAddr( device, "vkCreateValidationCacheEXT" ) );
1173  vkDestroyValidationCacheEXT = PFN_vkDestroyValidationCacheEXT( vkGetDeviceProcAddr( device, "vkDestroyValidationCacheEXT" ) );
1174  vkMergeValidationCachesEXT = PFN_vkMergeValidationCachesEXT( vkGetDeviceProcAddr( device, "vkMergeValidationCachesEXT" ) );
1175  vkGetValidationCacheDataEXT = PFN_vkGetValidationCacheDataEXT( vkGetDeviceProcAddr( device, "vkGetValidationCacheDataEXT" ) );
1176 
1177  //=== VK_NV_shading_rate_image ===
1178  vkCmdBindShadingRateImageNV = PFN_vkCmdBindShadingRateImageNV( vkGetDeviceProcAddr( device, "vkCmdBindShadingRateImageNV" ) );
1180  PFN_vkCmdSetViewportShadingRatePaletteNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportShadingRatePaletteNV" ) );
1181  vkCmdSetCoarseSampleOrderNV = PFN_vkCmdSetCoarseSampleOrderNV( vkGetDeviceProcAddr( device, "vkCmdSetCoarseSampleOrderNV" ) );
1182 
1183  //=== VK_NV_ray_tracing ===
1184  vkCreateAccelerationStructureNV = PFN_vkCreateAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCreateAccelerationStructureNV" ) );
1185  vkDestroyAccelerationStructureNV = PFN_vkDestroyAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkDestroyAccelerationStructureNV" ) );
1187  PFN_vkGetAccelerationStructureMemoryRequirementsNV( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureMemoryRequirementsNV" ) );
1188  vkBindAccelerationStructureMemoryNV = PFN_vkBindAccelerationStructureMemoryNV( vkGetDeviceProcAddr( device, "vkBindAccelerationStructureMemoryNV" ) );
1189  vkCmdBuildAccelerationStructureNV = PFN_vkCmdBuildAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructureNV" ) );
1190  vkCmdCopyAccelerationStructureNV = PFN_vkCmdCopyAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureNV" ) );
1191  vkCmdTraceRaysNV = PFN_vkCmdTraceRaysNV( vkGetDeviceProcAddr( device, "vkCmdTraceRaysNV" ) );
1192  vkCreateRayTracingPipelinesNV = PFN_vkCreateRayTracingPipelinesNV( vkGetDeviceProcAddr( device, "vkCreateRayTracingPipelinesNV" ) );
1193  vkGetRayTracingShaderGroupHandlesNV = PFN_vkGetRayTracingShaderGroupHandlesNV( vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupHandlesNV" ) );
1196  vkGetAccelerationStructureHandleNV = PFN_vkGetAccelerationStructureHandleNV( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureHandleNV" ) );
1198  PFN_vkCmdWriteAccelerationStructuresPropertiesNV( vkGetDeviceProcAddr( device, "vkCmdWriteAccelerationStructuresPropertiesNV" ) );
1199  vkCompileDeferredNV = PFN_vkCompileDeferredNV( vkGetDeviceProcAddr( device, "vkCompileDeferredNV" ) );
1200 
1201  //=== VK_KHR_maintenance3 ===
1202  vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupportKHR( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSupportKHR" ) );
1205 
1206  //=== VK_KHR_draw_indirect_count ===
1207  vkCmdDrawIndirectCountKHR = PFN_vkCmdDrawIndirectCountKHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountKHR" ) );
1208  if ( !vkCmdDrawIndirectCount )
1210  vkCmdDrawIndexedIndirectCountKHR = PFN_vkCmdDrawIndexedIndirectCountKHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCountKHR" ) );
1213 
1214  //=== VK_EXT_external_memory_host ===
1215  vkGetMemoryHostPointerPropertiesEXT = PFN_vkGetMemoryHostPointerPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetMemoryHostPointerPropertiesEXT" ) );
1216 
1217  //=== VK_AMD_buffer_marker ===
1218  vkCmdWriteBufferMarkerAMD = PFN_vkCmdWriteBufferMarkerAMD( vkGetDeviceProcAddr( device, "vkCmdWriteBufferMarkerAMD" ) );
1219 
1220  //=== VK_EXT_calibrated_timestamps ===
1221  vkGetCalibratedTimestampsEXT = PFN_vkGetCalibratedTimestampsEXT( vkGetDeviceProcAddr( device, "vkGetCalibratedTimestampsEXT" ) );
1224 
1225  //=== VK_NV_mesh_shader ===
1226  vkCmdDrawMeshTasksNV = PFN_vkCmdDrawMeshTasksNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksNV" ) );
1227  vkCmdDrawMeshTasksIndirectNV = PFN_vkCmdDrawMeshTasksIndirectNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectNV" ) );
1228  vkCmdDrawMeshTasksIndirectCountNV = PFN_vkCmdDrawMeshTasksIndirectCountNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectCountNV" ) );
1229 
1230  //=== VK_NV_scissor_exclusive ===
1231  vkCmdSetExclusiveScissorEnableNV = PFN_vkCmdSetExclusiveScissorEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetExclusiveScissorEnableNV" ) );
1232  vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV( vkGetDeviceProcAddr( device, "vkCmdSetExclusiveScissorNV" ) );
1233 
1234  //=== VK_NV_device_diagnostic_checkpoints ===
1235  vkCmdSetCheckpointNV = PFN_vkCmdSetCheckpointNV( vkGetDeviceProcAddr( device, "vkCmdSetCheckpointNV" ) );
1236  vkGetQueueCheckpointDataNV = PFN_vkGetQueueCheckpointDataNV( vkGetDeviceProcAddr( device, "vkGetQueueCheckpointDataNV" ) );
1237 
1238  //=== VK_KHR_timeline_semaphore ===
1239  vkGetSemaphoreCounterValueKHR = PFN_vkGetSemaphoreCounterValueKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreCounterValueKHR" ) );
1242  vkWaitSemaphoresKHR = PFN_vkWaitSemaphoresKHR( vkGetDeviceProcAddr( device, "vkWaitSemaphoresKHR" ) );
1243  if ( !vkWaitSemaphores )
1245  vkSignalSemaphoreKHR = PFN_vkSignalSemaphoreKHR( vkGetDeviceProcAddr( device, "vkSignalSemaphoreKHR" ) );
1246  if ( !vkSignalSemaphore )
1248 
1249  //=== VK_INTEL_performance_query ===
1250  vkInitializePerformanceApiINTEL = PFN_vkInitializePerformanceApiINTEL( vkGetDeviceProcAddr( device, "vkInitializePerformanceApiINTEL" ) );
1251  vkUninitializePerformanceApiINTEL = PFN_vkUninitializePerformanceApiINTEL( vkGetDeviceProcAddr( device, "vkUninitializePerformanceApiINTEL" ) );
1252  vkCmdSetPerformanceMarkerINTEL = PFN_vkCmdSetPerformanceMarkerINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceMarkerINTEL" ) );
1254  PFN_vkCmdSetPerformanceStreamMarkerINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceStreamMarkerINTEL" ) );
1255  vkCmdSetPerformanceOverrideINTEL = PFN_vkCmdSetPerformanceOverrideINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceOverrideINTEL" ) );
1257  PFN_vkAcquirePerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkAcquirePerformanceConfigurationINTEL" ) );
1259  PFN_vkReleasePerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkReleasePerformanceConfigurationINTEL" ) );
1261  PFN_vkQueueSetPerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkQueueSetPerformanceConfigurationINTEL" ) );
1262  vkGetPerformanceParameterINTEL = PFN_vkGetPerformanceParameterINTEL( vkGetDeviceProcAddr( device, "vkGetPerformanceParameterINTEL" ) );
1263 
1264  //=== VK_AMD_display_native_hdr ===
1265  vkSetLocalDimmingAMD = PFN_vkSetLocalDimmingAMD( vkGetDeviceProcAddr( device, "vkSetLocalDimmingAMD" ) );
1266 
1267  //=== VK_KHR_fragment_shading_rate ===
1268  vkCmdSetFragmentShadingRateKHR = PFN_vkCmdSetFragmentShadingRateKHR( vkGetDeviceProcAddr( device, "vkCmdSetFragmentShadingRateKHR" ) );
1269 
1270  //=== VK_EXT_buffer_device_address ===
1271  vkGetBufferDeviceAddressEXT = PFN_vkGetBufferDeviceAddressEXT( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddressEXT" ) );
1272  if ( !vkGetBufferDeviceAddress )
1274 
1275  //=== VK_KHR_present_wait ===
1276  vkWaitForPresentKHR = PFN_vkWaitForPresentKHR( vkGetDeviceProcAddr( device, "vkWaitForPresentKHR" ) );
1277 
1278 # if defined( VK_USE_PLATFORM_WIN32_KHR )
1279  //=== VK_EXT_full_screen_exclusive ===
1280  vkAcquireFullScreenExclusiveModeEXT = PFN_vkAcquireFullScreenExclusiveModeEXT( vkGetDeviceProcAddr( device, "vkAcquireFullScreenExclusiveModeEXT" ) );
1281  vkReleaseFullScreenExclusiveModeEXT = PFN_vkReleaseFullScreenExclusiveModeEXT( vkGetDeviceProcAddr( device, "vkReleaseFullScreenExclusiveModeEXT" ) );
1282  vkGetDeviceGroupSurfacePresentModes2EXT =
1283  PFN_vkGetDeviceGroupSurfacePresentModes2EXT( vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModes2EXT" ) );
1284 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
1285 
1286  //=== VK_KHR_buffer_device_address ===
1287  vkGetBufferDeviceAddressKHR = PFN_vkGetBufferDeviceAddressKHR( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddressKHR" ) );
1288  if ( !vkGetBufferDeviceAddress )
1290  vkGetBufferOpaqueCaptureAddressKHR = PFN_vkGetBufferOpaqueCaptureAddressKHR( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureAddressKHR" ) );
1294  PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryOpaqueCaptureAddressKHR" ) );
1297 
1298  //=== VK_EXT_line_rasterization ===
1299  vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleEXT" ) );
1300 
1301  //=== VK_EXT_host_query_reset ===
1302  vkResetQueryPoolEXT = PFN_vkResetQueryPoolEXT( vkGetDeviceProcAddr( device, "vkResetQueryPoolEXT" ) );
1303  if ( !vkResetQueryPool )
1305 
1306  //=== VK_EXT_extended_dynamic_state ===
1307  vkCmdSetCullModeEXT = PFN_vkCmdSetCullModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetCullModeEXT" ) );
1308  if ( !vkCmdSetCullMode )
1310  vkCmdSetFrontFaceEXT = PFN_vkCmdSetFrontFaceEXT( vkGetDeviceProcAddr( device, "vkCmdSetFrontFaceEXT" ) );
1311  if ( !vkCmdSetFrontFace )
1313  vkCmdSetPrimitiveTopologyEXT = PFN_vkCmdSetPrimitiveTopologyEXT( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveTopologyEXT" ) );
1316  vkCmdSetViewportWithCountEXT = PFN_vkCmdSetViewportWithCountEXT( vkGetDeviceProcAddr( device, "vkCmdSetViewportWithCountEXT" ) );
1319  vkCmdSetScissorWithCountEXT = PFN_vkCmdSetScissorWithCountEXT( vkGetDeviceProcAddr( device, "vkCmdSetScissorWithCountEXT" ) );
1320  if ( !vkCmdSetScissorWithCount )
1322  vkCmdBindVertexBuffers2EXT = PFN_vkCmdBindVertexBuffers2EXT( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers2EXT" ) );
1323  if ( !vkCmdBindVertexBuffers2 )
1325  vkCmdSetDepthTestEnableEXT = PFN_vkCmdSetDepthTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthTestEnableEXT" ) );
1326  if ( !vkCmdSetDepthTestEnable )
1328  vkCmdSetDepthWriteEnableEXT = PFN_vkCmdSetDepthWriteEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthWriteEnableEXT" ) );
1329  if ( !vkCmdSetDepthWriteEnable )
1331  vkCmdSetDepthCompareOpEXT = PFN_vkCmdSetDepthCompareOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthCompareOpEXT" ) );
1332  if ( !vkCmdSetDepthCompareOp )
1334  vkCmdSetDepthBoundsTestEnableEXT = PFN_vkCmdSetDepthBoundsTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBoundsTestEnableEXT" ) );
1337  vkCmdSetStencilTestEnableEXT = PFN_vkCmdSetStencilTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetStencilTestEnableEXT" ) );
1340  vkCmdSetStencilOpEXT = PFN_vkCmdSetStencilOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetStencilOpEXT" ) );
1341  if ( !vkCmdSetStencilOp )
1343 
1344  //=== VK_KHR_deferred_host_operations ===
1345  vkCreateDeferredOperationKHR = PFN_vkCreateDeferredOperationKHR( vkGetDeviceProcAddr( device, "vkCreateDeferredOperationKHR" ) );
1346  vkDestroyDeferredOperationKHR = PFN_vkDestroyDeferredOperationKHR( vkGetDeviceProcAddr( device, "vkDestroyDeferredOperationKHR" ) );
1348  PFN_vkGetDeferredOperationMaxConcurrencyKHR( vkGetDeviceProcAddr( device, "vkGetDeferredOperationMaxConcurrencyKHR" ) );
1349  vkGetDeferredOperationResultKHR = PFN_vkGetDeferredOperationResultKHR( vkGetDeviceProcAddr( device, "vkGetDeferredOperationResultKHR" ) );
1350  vkDeferredOperationJoinKHR = PFN_vkDeferredOperationJoinKHR( vkGetDeviceProcAddr( device, "vkDeferredOperationJoinKHR" ) );
1351 
1352  //=== VK_KHR_pipeline_executable_properties ===
1354  PFN_vkGetPipelineExecutablePropertiesKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutablePropertiesKHR" ) );
1356  PFN_vkGetPipelineExecutableStatisticsKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutableStatisticsKHR" ) );
1358  PFN_vkGetPipelineExecutableInternalRepresentationsKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutableInternalRepresentationsKHR" ) );
1359 
1360  //=== VK_EXT_host_image_copy ===
1361  vkCopyMemoryToImageEXT = PFN_vkCopyMemoryToImageEXT( vkGetDeviceProcAddr( device, "vkCopyMemoryToImageEXT" ) );
1362  vkCopyImageToMemoryEXT = PFN_vkCopyImageToMemoryEXT( vkGetDeviceProcAddr( device, "vkCopyImageToMemoryEXT" ) );
1363  vkCopyImageToImageEXT = PFN_vkCopyImageToImageEXT( vkGetDeviceProcAddr( device, "vkCopyImageToImageEXT" ) );
1364  vkTransitionImageLayoutEXT = PFN_vkTransitionImageLayoutEXT( vkGetDeviceProcAddr( device, "vkTransitionImageLayoutEXT" ) );
1365  vkGetImageSubresourceLayout2EXT = PFN_vkGetImageSubresourceLayout2EXT( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout2EXT" ) );
1368 
1369  //=== VK_KHR_map_memory2 ===
1370  vkMapMemory2KHR = PFN_vkMapMemory2KHR( vkGetDeviceProcAddr( device, "vkMapMemory2KHR" ) );
1371  vkUnmapMemory2KHR = PFN_vkUnmapMemory2KHR( vkGetDeviceProcAddr( device, "vkUnmapMemory2KHR" ) );
1372 
1373  //=== VK_EXT_swapchain_maintenance1 ===
1374  vkReleaseSwapchainImagesEXT = PFN_vkReleaseSwapchainImagesEXT( vkGetDeviceProcAddr( device, "vkReleaseSwapchainImagesEXT" ) );
1375 
1376  //=== VK_NV_device_generated_commands ===
1378  PFN_vkGetGeneratedCommandsMemoryRequirementsNV( vkGetDeviceProcAddr( device, "vkGetGeneratedCommandsMemoryRequirementsNV" ) );
1379  vkCmdPreprocessGeneratedCommandsNV = PFN_vkCmdPreprocessGeneratedCommandsNV( vkGetDeviceProcAddr( device, "vkCmdPreprocessGeneratedCommandsNV" ) );
1380  vkCmdExecuteGeneratedCommandsNV = PFN_vkCmdExecuteGeneratedCommandsNV( vkGetDeviceProcAddr( device, "vkCmdExecuteGeneratedCommandsNV" ) );
1381  vkCmdBindPipelineShaderGroupNV = PFN_vkCmdBindPipelineShaderGroupNV( vkGetDeviceProcAddr( device, "vkCmdBindPipelineShaderGroupNV" ) );
1382  vkCreateIndirectCommandsLayoutNV = PFN_vkCreateIndirectCommandsLayoutNV( vkGetDeviceProcAddr( device, "vkCreateIndirectCommandsLayoutNV" ) );
1383  vkDestroyIndirectCommandsLayoutNV = PFN_vkDestroyIndirectCommandsLayoutNV( vkGetDeviceProcAddr( device, "vkDestroyIndirectCommandsLayoutNV" ) );
1384 
1385  //=== VK_EXT_depth_bias_control ===
1386  vkCmdSetDepthBias2EXT = PFN_vkCmdSetDepthBias2EXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBias2EXT" ) );
1387 
1388  //=== VK_EXT_private_data ===
1389  vkCreatePrivateDataSlotEXT = PFN_vkCreatePrivateDataSlotEXT( vkGetDeviceProcAddr( device, "vkCreatePrivateDataSlotEXT" ) );
1390  if ( !vkCreatePrivateDataSlot )
1392  vkDestroyPrivateDataSlotEXT = PFN_vkDestroyPrivateDataSlotEXT( vkGetDeviceProcAddr( device, "vkDestroyPrivateDataSlotEXT" ) );
1393  if ( !vkDestroyPrivateDataSlot )
1395  vkSetPrivateDataEXT = PFN_vkSetPrivateDataEXT( vkGetDeviceProcAddr( device, "vkSetPrivateDataEXT" ) );
1396  if ( !vkSetPrivateData )
1398  vkGetPrivateDataEXT = PFN_vkGetPrivateDataEXT( vkGetDeviceProcAddr( device, "vkGetPrivateDataEXT" ) );
1399  if ( !vkGetPrivateData )
1401 
1402  //=== VK_KHR_video_encode_queue ===
1404  PFN_vkGetEncodedVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkGetEncodedVideoSessionParametersKHR" ) );
1405  vkCmdEncodeVideoKHR = PFN_vkCmdEncodeVideoKHR( vkGetDeviceProcAddr( device, "vkCmdEncodeVideoKHR" ) );
1406 
1407 # if defined( VK_ENABLE_BETA_EXTENSIONS )
1408  //=== VK_NV_cuda_kernel_launch ===
1409  vkCreateCudaModuleNV = PFN_vkCreateCudaModuleNV( vkGetDeviceProcAddr( device, "vkCreateCudaModuleNV" ) );
1410  vkGetCudaModuleCacheNV = PFN_vkGetCudaModuleCacheNV( vkGetDeviceProcAddr( device, "vkGetCudaModuleCacheNV" ) );
1411  vkCreateCudaFunctionNV = PFN_vkCreateCudaFunctionNV( vkGetDeviceProcAddr( device, "vkCreateCudaFunctionNV" ) );
1412  vkDestroyCudaModuleNV = PFN_vkDestroyCudaModuleNV( vkGetDeviceProcAddr( device, "vkDestroyCudaModuleNV" ) );
1413  vkDestroyCudaFunctionNV = PFN_vkDestroyCudaFunctionNV( vkGetDeviceProcAddr( device, "vkDestroyCudaFunctionNV" ) );
1414  vkCmdCudaLaunchKernelNV = PFN_vkCmdCudaLaunchKernelNV( vkGetDeviceProcAddr( device, "vkCmdCudaLaunchKernelNV" ) );
1415 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
1416 
1417 # if defined( VK_USE_PLATFORM_METAL_EXT )
1418  //=== VK_EXT_metal_objects ===
1419  vkExportMetalObjectsEXT = PFN_vkExportMetalObjectsEXT( vkGetDeviceProcAddr( device, "vkExportMetalObjectsEXT" ) );
1420 # endif /*VK_USE_PLATFORM_METAL_EXT*/
1421 
1422  //=== VK_KHR_synchronization2 ===
1423  vkCmdSetEvent2KHR = PFN_vkCmdSetEvent2KHR( vkGetDeviceProcAddr( device, "vkCmdSetEvent2KHR" ) );
1424  if ( !vkCmdSetEvent2 )
1426  vkCmdResetEvent2KHR = PFN_vkCmdResetEvent2KHR( vkGetDeviceProcAddr( device, "vkCmdResetEvent2KHR" ) );
1427  if ( !vkCmdResetEvent2 )
1429  vkCmdWaitEvents2KHR = PFN_vkCmdWaitEvents2KHR( vkGetDeviceProcAddr( device, "vkCmdWaitEvents2KHR" ) );
1430  if ( !vkCmdWaitEvents2 )
1432  vkCmdPipelineBarrier2KHR = PFN_vkCmdPipelineBarrier2KHR( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier2KHR" ) );
1433  if ( !vkCmdPipelineBarrier2 )
1435  vkCmdWriteTimestamp2KHR = PFN_vkCmdWriteTimestamp2KHR( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp2KHR" ) );
1436  if ( !vkCmdWriteTimestamp2 )
1438  vkQueueSubmit2KHR = PFN_vkQueueSubmit2KHR( vkGetDeviceProcAddr( device, "vkQueueSubmit2KHR" ) );
1439  if ( !vkQueueSubmit2 )
1441  vkCmdWriteBufferMarker2AMD = PFN_vkCmdWriteBufferMarker2AMD( vkGetDeviceProcAddr( device, "vkCmdWriteBufferMarker2AMD" ) );
1442  vkGetQueueCheckpointData2NV = PFN_vkGetQueueCheckpointData2NV( vkGetDeviceProcAddr( device, "vkGetQueueCheckpointData2NV" ) );
1443 
1444  //=== VK_EXT_descriptor_buffer ===
1445  vkGetDescriptorSetLayoutSizeEXT = PFN_vkGetDescriptorSetLayoutSizeEXT( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSizeEXT" ) );
1447  PFN_vkGetDescriptorSetLayoutBindingOffsetEXT( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutBindingOffsetEXT" ) );
1448  vkGetDescriptorEXT = PFN_vkGetDescriptorEXT( vkGetDeviceProcAddr( device, "vkGetDescriptorEXT" ) );
1449  vkCmdBindDescriptorBuffersEXT = PFN_vkCmdBindDescriptorBuffersEXT( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorBuffersEXT" ) );
1450  vkCmdSetDescriptorBufferOffsetsEXT = PFN_vkCmdSetDescriptorBufferOffsetsEXT( vkGetDeviceProcAddr( device, "vkCmdSetDescriptorBufferOffsetsEXT" ) );
1452  PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorBufferEmbeddedSamplersEXT" ) );
1454  PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureDescriptorDataEXT" ) );
1456  PFN_vkGetImageOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetImageOpaqueCaptureDescriptorDataEXT" ) );
1458  PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetImageViewOpaqueCaptureDescriptorDataEXT" ) );
1460  PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetSamplerOpaqueCaptureDescriptorDataEXT" ) );
1462  vkGetDeviceProcAddr( device, "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT" ) );
1463 
1464  //=== VK_NV_fragment_shading_rate_enums ===
1465  vkCmdSetFragmentShadingRateEnumNV = PFN_vkCmdSetFragmentShadingRateEnumNV( vkGetDeviceProcAddr( device, "vkCmdSetFragmentShadingRateEnumNV" ) );
1466 
1467  //=== VK_EXT_mesh_shader ===
1468  vkCmdDrawMeshTasksEXT = PFN_vkCmdDrawMeshTasksEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksEXT" ) );
1469  vkCmdDrawMeshTasksIndirectEXT = PFN_vkCmdDrawMeshTasksIndirectEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectEXT" ) );
1470  vkCmdDrawMeshTasksIndirectCountEXT = PFN_vkCmdDrawMeshTasksIndirectCountEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectCountEXT" ) );
1471 
1472  //=== VK_KHR_copy_commands2 ===
1473  vkCmdCopyBuffer2KHR = PFN_vkCmdCopyBuffer2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer2KHR" ) );
1474  if ( !vkCmdCopyBuffer2 )
1476  vkCmdCopyImage2KHR = PFN_vkCmdCopyImage2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyImage2KHR" ) );
1477  if ( !vkCmdCopyImage2 )
1479  vkCmdCopyBufferToImage2KHR = PFN_vkCmdCopyBufferToImage2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage2KHR" ) );
1480  if ( !vkCmdCopyBufferToImage2 )
1482  vkCmdCopyImageToBuffer2KHR = PFN_vkCmdCopyImageToBuffer2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer2KHR" ) );
1483  if ( !vkCmdCopyImageToBuffer2 )
1485  vkCmdBlitImage2KHR = PFN_vkCmdBlitImage2KHR( vkGetDeviceProcAddr( device, "vkCmdBlitImage2KHR" ) );
1486  if ( !vkCmdBlitImage2 )
1488  vkCmdResolveImage2KHR = PFN_vkCmdResolveImage2KHR( vkGetDeviceProcAddr( device, "vkCmdResolveImage2KHR" ) );
1489  if ( !vkCmdResolveImage2 )
1491 
1492  //=== VK_EXT_device_fault ===
1493  vkGetDeviceFaultInfoEXT = PFN_vkGetDeviceFaultInfoEXT( vkGetDeviceProcAddr( device, "vkGetDeviceFaultInfoEXT" ) );
1494 
1495  //=== VK_EXT_vertex_input_dynamic_state ===
1496  vkCmdSetVertexInputEXT = PFN_vkCmdSetVertexInputEXT( vkGetDeviceProcAddr( device, "vkCmdSetVertexInputEXT" ) );
1497 
1498 # if defined( VK_USE_PLATFORM_FUCHSIA )
1499  //=== VK_FUCHSIA_external_memory ===
1500  vkGetMemoryZirconHandleFUCHSIA = PFN_vkGetMemoryZirconHandleFUCHSIA( vkGetDeviceProcAddr( device, "vkGetMemoryZirconHandleFUCHSIA" ) );
1501  vkGetMemoryZirconHandlePropertiesFUCHSIA =
1502  PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA( vkGetDeviceProcAddr( device, "vkGetMemoryZirconHandlePropertiesFUCHSIA" ) );
1503 # endif /*VK_USE_PLATFORM_FUCHSIA*/
1504 
1505 # if defined( VK_USE_PLATFORM_FUCHSIA )
1506  //=== VK_FUCHSIA_external_semaphore ===
1507  vkImportSemaphoreZirconHandleFUCHSIA =
1508  PFN_vkImportSemaphoreZirconHandleFUCHSIA( vkGetDeviceProcAddr( device, "vkImportSemaphoreZirconHandleFUCHSIA" ) );
1509  vkGetSemaphoreZirconHandleFUCHSIA = PFN_vkGetSemaphoreZirconHandleFUCHSIA( vkGetDeviceProcAddr( device, "vkGetSemaphoreZirconHandleFUCHSIA" ) );
1510 # endif /*VK_USE_PLATFORM_FUCHSIA*/
1511 
1512 # if defined( VK_USE_PLATFORM_FUCHSIA )
1513  //=== VK_FUCHSIA_buffer_collection ===
1514  vkCreateBufferCollectionFUCHSIA = PFN_vkCreateBufferCollectionFUCHSIA( vkGetDeviceProcAddr( device, "vkCreateBufferCollectionFUCHSIA" ) );
1515  vkSetBufferCollectionImageConstraintsFUCHSIA =
1516  PFN_vkSetBufferCollectionImageConstraintsFUCHSIA( vkGetDeviceProcAddr( device, "vkSetBufferCollectionImageConstraintsFUCHSIA" ) );
1517  vkSetBufferCollectionBufferConstraintsFUCHSIA =
1518  PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA( vkGetDeviceProcAddr( device, "vkSetBufferCollectionBufferConstraintsFUCHSIA" ) );
1519  vkDestroyBufferCollectionFUCHSIA = PFN_vkDestroyBufferCollectionFUCHSIA( vkGetDeviceProcAddr( device, "vkDestroyBufferCollectionFUCHSIA" ) );
1520  vkGetBufferCollectionPropertiesFUCHSIA =
1521  PFN_vkGetBufferCollectionPropertiesFUCHSIA( vkGetDeviceProcAddr( device, "vkGetBufferCollectionPropertiesFUCHSIA" ) );
1522 # endif /*VK_USE_PLATFORM_FUCHSIA*/
1523 
1524  //=== VK_HUAWEI_subpass_shading ===
1526  PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( vkGetDeviceProcAddr( device, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI" ) );
1527  vkCmdSubpassShadingHUAWEI = PFN_vkCmdSubpassShadingHUAWEI( vkGetDeviceProcAddr( device, "vkCmdSubpassShadingHUAWEI" ) );
1528 
1529  //=== VK_HUAWEI_invocation_mask ===
1530  vkCmdBindInvocationMaskHUAWEI = PFN_vkCmdBindInvocationMaskHUAWEI( vkGetDeviceProcAddr( device, "vkCmdBindInvocationMaskHUAWEI" ) );
1531 
1532  //=== VK_NV_external_memory_rdma ===
1533  vkGetMemoryRemoteAddressNV = PFN_vkGetMemoryRemoteAddressNV( vkGetDeviceProcAddr( device, "vkGetMemoryRemoteAddressNV" ) );
1534 
1535  //=== VK_EXT_pipeline_properties ===
1536  vkGetPipelinePropertiesEXT = PFN_vkGetPipelinePropertiesEXT( vkGetDeviceProcAddr( device, "vkGetPipelinePropertiesEXT" ) );
1537 
1538  //=== VK_EXT_extended_dynamic_state2 ===
1539  vkCmdSetPatchControlPointsEXT = PFN_vkCmdSetPatchControlPointsEXT( vkGetDeviceProcAddr( device, "vkCmdSetPatchControlPointsEXT" ) );
1540  vkCmdSetRasterizerDiscardEnableEXT = PFN_vkCmdSetRasterizerDiscardEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizerDiscardEnableEXT" ) );
1543  vkCmdSetDepthBiasEnableEXT = PFN_vkCmdSetDepthBiasEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBiasEnableEXT" ) );
1544  if ( !vkCmdSetDepthBiasEnable )
1546  vkCmdSetLogicOpEXT = PFN_vkCmdSetLogicOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetLogicOpEXT" ) );
1547  vkCmdSetPrimitiveRestartEnableEXT = PFN_vkCmdSetPrimitiveRestartEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveRestartEnableEXT" ) );
1550 
1551  //=== VK_EXT_color_write_enable ===
1552  vkCmdSetColorWriteEnableEXT = PFN_vkCmdSetColorWriteEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorWriteEnableEXT" ) );
1553 
1554  //=== VK_KHR_ray_tracing_maintenance1 ===
1555  vkCmdTraceRaysIndirect2KHR = PFN_vkCmdTraceRaysIndirect2KHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysIndirect2KHR" ) );
1556 
1557  //=== VK_EXT_multi_draw ===
1558  vkCmdDrawMultiEXT = PFN_vkCmdDrawMultiEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMultiEXT" ) );
1559  vkCmdDrawMultiIndexedEXT = PFN_vkCmdDrawMultiIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMultiIndexedEXT" ) );
1560 
1561  //=== VK_EXT_opacity_micromap ===
1562  vkCreateMicromapEXT = PFN_vkCreateMicromapEXT( vkGetDeviceProcAddr( device, "vkCreateMicromapEXT" ) );
1563  vkDestroyMicromapEXT = PFN_vkDestroyMicromapEXT( vkGetDeviceProcAddr( device, "vkDestroyMicromapEXT" ) );
1564  vkCmdBuildMicromapsEXT = PFN_vkCmdBuildMicromapsEXT( vkGetDeviceProcAddr( device, "vkCmdBuildMicromapsEXT" ) );
1565  vkBuildMicromapsEXT = PFN_vkBuildMicromapsEXT( vkGetDeviceProcAddr( device, "vkBuildMicromapsEXT" ) );
1566  vkCopyMicromapEXT = PFN_vkCopyMicromapEXT( vkGetDeviceProcAddr( device, "vkCopyMicromapEXT" ) );
1567  vkCopyMicromapToMemoryEXT = PFN_vkCopyMicromapToMemoryEXT( vkGetDeviceProcAddr( device, "vkCopyMicromapToMemoryEXT" ) );
1568  vkCopyMemoryToMicromapEXT = PFN_vkCopyMemoryToMicromapEXT( vkGetDeviceProcAddr( device, "vkCopyMemoryToMicromapEXT" ) );
1569  vkWriteMicromapsPropertiesEXT = PFN_vkWriteMicromapsPropertiesEXT( vkGetDeviceProcAddr( device, "vkWriteMicromapsPropertiesEXT" ) );
1570  vkCmdCopyMicromapEXT = PFN_vkCmdCopyMicromapEXT( vkGetDeviceProcAddr( device, "vkCmdCopyMicromapEXT" ) );
1571  vkCmdCopyMicromapToMemoryEXT = PFN_vkCmdCopyMicromapToMemoryEXT( vkGetDeviceProcAddr( device, "vkCmdCopyMicromapToMemoryEXT" ) );
1572  vkCmdCopyMemoryToMicromapEXT = PFN_vkCmdCopyMemoryToMicromapEXT( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToMicromapEXT" ) );
1573  vkCmdWriteMicromapsPropertiesEXT = PFN_vkCmdWriteMicromapsPropertiesEXT( vkGetDeviceProcAddr( device, "vkCmdWriteMicromapsPropertiesEXT" ) );
1574  vkGetDeviceMicromapCompatibilityEXT = PFN_vkGetDeviceMicromapCompatibilityEXT( vkGetDeviceProcAddr( device, "vkGetDeviceMicromapCompatibilityEXT" ) );
1575  vkGetMicromapBuildSizesEXT = PFN_vkGetMicromapBuildSizesEXT( vkGetDeviceProcAddr( device, "vkGetMicromapBuildSizesEXT" ) );
1576 
1577  //=== VK_HUAWEI_cluster_culling_shader ===
1578  vkCmdDrawClusterHUAWEI = PFN_vkCmdDrawClusterHUAWEI( vkGetDeviceProcAddr( device, "vkCmdDrawClusterHUAWEI" ) );
1579  vkCmdDrawClusterIndirectHUAWEI = PFN_vkCmdDrawClusterIndirectHUAWEI( vkGetDeviceProcAddr( device, "vkCmdDrawClusterIndirectHUAWEI" ) );
1580 
1581  //=== VK_EXT_pageable_device_local_memory ===
1582  vkSetDeviceMemoryPriorityEXT = PFN_vkSetDeviceMemoryPriorityEXT( vkGetDeviceProcAddr( device, "vkSetDeviceMemoryPriorityEXT" ) );
1583 
1584  //=== VK_KHR_maintenance4 ===
1586  PFN_vkGetDeviceBufferMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetDeviceBufferMemoryRequirementsKHR" ) );
1590  PFN_vkGetDeviceImageMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetDeviceImageMemoryRequirementsKHR" ) );
1594  PFN_vkGetDeviceImageSparseMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetDeviceImageSparseMemoryRequirementsKHR" ) );
1597 
1598  //=== VK_VALVE_descriptor_set_host_mapping ===
1600  PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutHostMappingInfoVALVE" ) );
1601  vkGetDescriptorSetHostMappingVALVE = PFN_vkGetDescriptorSetHostMappingVALVE( vkGetDeviceProcAddr( device, "vkGetDescriptorSetHostMappingVALVE" ) );
1602 
1603  //=== VK_NV_copy_memory_indirect ===
1604  vkCmdCopyMemoryIndirectNV = PFN_vkCmdCopyMemoryIndirectNV( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryIndirectNV" ) );
1605  vkCmdCopyMemoryToImageIndirectNV = PFN_vkCmdCopyMemoryToImageIndirectNV( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToImageIndirectNV" ) );
1606 
1607  //=== VK_NV_memory_decompression ===
1608  vkCmdDecompressMemoryNV = PFN_vkCmdDecompressMemoryNV( vkGetDeviceProcAddr( device, "vkCmdDecompressMemoryNV" ) );
1610  PFN_vkCmdDecompressMemoryIndirectCountNV( vkGetDeviceProcAddr( device, "vkCmdDecompressMemoryIndirectCountNV" ) );
1611 
1612  //=== VK_NV_device_generated_commands_compute ===
1614  PFN_vkGetPipelineIndirectMemoryRequirementsNV( vkGetDeviceProcAddr( device, "vkGetPipelineIndirectMemoryRequirementsNV" ) );
1615  vkCmdUpdatePipelineIndirectBufferNV = PFN_vkCmdUpdatePipelineIndirectBufferNV( vkGetDeviceProcAddr( device, "vkCmdUpdatePipelineIndirectBufferNV" ) );
1617  PFN_vkGetPipelineIndirectDeviceAddressNV( vkGetDeviceProcAddr( device, "vkGetPipelineIndirectDeviceAddressNV" ) );
1618 
1619  //=== VK_EXT_extended_dynamic_state3 ===
1620  vkCmdSetTessellationDomainOriginEXT = PFN_vkCmdSetTessellationDomainOriginEXT( vkGetDeviceProcAddr( device, "vkCmdSetTessellationDomainOriginEXT" ) );
1621  vkCmdSetDepthClampEnableEXT = PFN_vkCmdSetDepthClampEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClampEnableEXT" ) );
1622  vkCmdSetPolygonModeEXT = PFN_vkCmdSetPolygonModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetPolygonModeEXT" ) );
1623  vkCmdSetRasterizationSamplesEXT = PFN_vkCmdSetRasterizationSamplesEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizationSamplesEXT" ) );
1624  vkCmdSetSampleMaskEXT = PFN_vkCmdSetSampleMaskEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleMaskEXT" ) );
1625  vkCmdSetAlphaToCoverageEnableEXT = PFN_vkCmdSetAlphaToCoverageEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetAlphaToCoverageEnableEXT" ) );
1626  vkCmdSetAlphaToOneEnableEXT = PFN_vkCmdSetAlphaToOneEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetAlphaToOneEnableEXT" ) );
1627  vkCmdSetLogicOpEnableEXT = PFN_vkCmdSetLogicOpEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetLogicOpEnableEXT" ) );
1628  vkCmdSetColorBlendEnableEXT = PFN_vkCmdSetColorBlendEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorBlendEnableEXT" ) );
1629  vkCmdSetColorBlendEquationEXT = PFN_vkCmdSetColorBlendEquationEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorBlendEquationEXT" ) );
1630  vkCmdSetColorWriteMaskEXT = PFN_vkCmdSetColorWriteMaskEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorWriteMaskEXT" ) );
1631  vkCmdSetRasterizationStreamEXT = PFN_vkCmdSetRasterizationStreamEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizationStreamEXT" ) );
1633  PFN_vkCmdSetConservativeRasterizationModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetConservativeRasterizationModeEXT" ) );
1635  PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT( vkGetDeviceProcAddr( device, "vkCmdSetExtraPrimitiveOverestimationSizeEXT" ) );
1636  vkCmdSetDepthClipEnableEXT = PFN_vkCmdSetDepthClipEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClipEnableEXT" ) );
1637  vkCmdSetSampleLocationsEnableEXT = PFN_vkCmdSetSampleLocationsEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleLocationsEnableEXT" ) );
1638  vkCmdSetColorBlendAdvancedEXT = PFN_vkCmdSetColorBlendAdvancedEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorBlendAdvancedEXT" ) );
1639  vkCmdSetProvokingVertexModeEXT = PFN_vkCmdSetProvokingVertexModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetProvokingVertexModeEXT" ) );
1640  vkCmdSetLineRasterizationModeEXT = PFN_vkCmdSetLineRasterizationModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineRasterizationModeEXT" ) );
1641  vkCmdSetLineStippleEnableEXT = PFN_vkCmdSetLineStippleEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleEnableEXT" ) );
1643  PFN_vkCmdSetDepthClipNegativeOneToOneEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClipNegativeOneToOneEXT" ) );
1644  vkCmdSetViewportWScalingEnableNV = PFN_vkCmdSetViewportWScalingEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportWScalingEnableNV" ) );
1645  vkCmdSetViewportSwizzleNV = PFN_vkCmdSetViewportSwizzleNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportSwizzleNV" ) );
1646  vkCmdSetCoverageToColorEnableNV = PFN_vkCmdSetCoverageToColorEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageToColorEnableNV" ) );
1647  vkCmdSetCoverageToColorLocationNV = PFN_vkCmdSetCoverageToColorLocationNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageToColorLocationNV" ) );
1648  vkCmdSetCoverageModulationModeNV = PFN_vkCmdSetCoverageModulationModeNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageModulationModeNV" ) );
1650  PFN_vkCmdSetCoverageModulationTableEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageModulationTableEnableNV" ) );
1651  vkCmdSetCoverageModulationTableNV = PFN_vkCmdSetCoverageModulationTableNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageModulationTableNV" ) );
1652  vkCmdSetShadingRateImageEnableNV = PFN_vkCmdSetShadingRateImageEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetShadingRateImageEnableNV" ) );
1654  PFN_vkCmdSetRepresentativeFragmentTestEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetRepresentativeFragmentTestEnableNV" ) );
1655  vkCmdSetCoverageReductionModeNV = PFN_vkCmdSetCoverageReductionModeNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageReductionModeNV" ) );
1656 
1657  //=== VK_EXT_shader_module_identifier ===
1658  vkGetShaderModuleIdentifierEXT = PFN_vkGetShaderModuleIdentifierEXT( vkGetDeviceProcAddr( device, "vkGetShaderModuleIdentifierEXT" ) );
1660  PFN_vkGetShaderModuleCreateInfoIdentifierEXT( vkGetDeviceProcAddr( device, "vkGetShaderModuleCreateInfoIdentifierEXT" ) );
1661 
1662  //=== VK_NV_optical_flow ===
1663  vkCreateOpticalFlowSessionNV = PFN_vkCreateOpticalFlowSessionNV( vkGetDeviceProcAddr( device, "vkCreateOpticalFlowSessionNV" ) );
1664  vkDestroyOpticalFlowSessionNV = PFN_vkDestroyOpticalFlowSessionNV( vkGetDeviceProcAddr( device, "vkDestroyOpticalFlowSessionNV" ) );
1665  vkBindOpticalFlowSessionImageNV = PFN_vkBindOpticalFlowSessionImageNV( vkGetDeviceProcAddr( device, "vkBindOpticalFlowSessionImageNV" ) );
1666  vkCmdOpticalFlowExecuteNV = PFN_vkCmdOpticalFlowExecuteNV( vkGetDeviceProcAddr( device, "vkCmdOpticalFlowExecuteNV" ) );
1667 
1668  //=== VK_KHR_maintenance5 ===
1669  vkCmdBindIndexBuffer2KHR = PFN_vkCmdBindIndexBuffer2KHR( vkGetDeviceProcAddr( device, "vkCmdBindIndexBuffer2KHR" ) );
1670  vkGetRenderingAreaGranularityKHR = PFN_vkGetRenderingAreaGranularityKHR( vkGetDeviceProcAddr( device, "vkGetRenderingAreaGranularityKHR" ) );
1672  PFN_vkGetDeviceImageSubresourceLayoutKHR( vkGetDeviceProcAddr( device, "vkGetDeviceImageSubresourceLayoutKHR" ) );
1673  vkGetImageSubresourceLayout2KHR = PFN_vkGetImageSubresourceLayout2KHR( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout2KHR" ) );
1674 
1675  //=== VK_EXT_shader_object ===
1676  vkCreateShadersEXT = PFN_vkCreateShadersEXT( vkGetDeviceProcAddr( device, "vkCreateShadersEXT" ) );
1677  vkDestroyShaderEXT = PFN_vkDestroyShaderEXT( vkGetDeviceProcAddr( device, "vkDestroyShaderEXT" ) );
1678  vkGetShaderBinaryDataEXT = PFN_vkGetShaderBinaryDataEXT( vkGetDeviceProcAddr( device, "vkGetShaderBinaryDataEXT" ) );
1679  vkCmdBindShadersEXT = PFN_vkCmdBindShadersEXT( vkGetDeviceProcAddr( device, "vkCmdBindShadersEXT" ) );
1680 
1681  //=== VK_QCOM_tile_properties ===
1682  vkGetFramebufferTilePropertiesQCOM = PFN_vkGetFramebufferTilePropertiesQCOM( vkGetDeviceProcAddr( device, "vkGetFramebufferTilePropertiesQCOM" ) );
1684  PFN_vkGetDynamicRenderingTilePropertiesQCOM( vkGetDeviceProcAddr( device, "vkGetDynamicRenderingTilePropertiesQCOM" ) );
1685 
1686  //=== VK_NV_low_latency2 ===
1687  vkSetLatencySleepModeNV = PFN_vkSetLatencySleepModeNV( vkGetDeviceProcAddr( device, "vkSetLatencySleepModeNV" ) );
1688  vkLatencySleepNV = PFN_vkLatencySleepNV( vkGetDeviceProcAddr( device, "vkLatencySleepNV" ) );
1689  vkSetLatencyMarkerNV = PFN_vkSetLatencyMarkerNV( vkGetDeviceProcAddr( device, "vkSetLatencyMarkerNV" ) );
1690  vkGetLatencyTimingsNV = PFN_vkGetLatencyTimingsNV( vkGetDeviceProcAddr( device, "vkGetLatencyTimingsNV" ) );
1691  vkQueueNotifyOutOfBandNV = PFN_vkQueueNotifyOutOfBandNV( vkGetDeviceProcAddr( device, "vkQueueNotifyOutOfBandNV" ) );
1692 
1693  //=== VK_EXT_attachment_feedback_loop_dynamic_state ===
1695  PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetAttachmentFeedbackLoopEnableEXT" ) );
1696 
1697 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
1698  //=== VK_QNX_external_memory_screen_buffer ===
1699  vkGetScreenBufferPropertiesQNX = PFN_vkGetScreenBufferPropertiesQNX( vkGetDeviceProcAddr( device, "vkGetScreenBufferPropertiesQNX" ) );
1700 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/
1701 
1702  //=== VK_KHR_calibrated_timestamps ===
1703  vkGetCalibratedTimestampsKHR = PFN_vkGetCalibratedTimestampsKHR( vkGetDeviceProcAddr( device, "vkGetCalibratedTimestampsKHR" ) );
1704 
1705  //=== VK_KHR_maintenance6 ===
1706  vkCmdBindDescriptorSets2KHR = PFN_vkCmdBindDescriptorSets2KHR( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorSets2KHR" ) );
1707  vkCmdPushConstants2KHR = PFN_vkCmdPushConstants2KHR( vkGetDeviceProcAddr( device, "vkCmdPushConstants2KHR" ) );
1708  vkCmdPushDescriptorSet2KHR = PFN_vkCmdPushDescriptorSet2KHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSet2KHR" ) );
1710  PFN_vkCmdPushDescriptorSetWithTemplate2KHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetWithTemplate2KHR" ) );
1711  vkCmdSetDescriptorBufferOffsets2EXT = PFN_vkCmdSetDescriptorBufferOffsets2EXT( vkGetDeviceProcAddr( device, "vkCmdSetDescriptorBufferOffsets2EXT" ) );
1713  PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT" ) );
1714  }
1715 
1716  public:
1717  //=== VK_VERSION_1_0 ===
1839 
1840  //=== VK_VERSION_1_1 ===
1857 
1858  //=== VK_VERSION_1_2 ===
1872 
1873  //=== VK_VERSION_1_3 ===
1910 
1911  //=== VK_KHR_swapchain ===
1920 
1921  //=== VK_KHR_display_swapchain ===
1923 
1924  //=== VK_EXT_debug_marker ===
1930 
1931  //=== VK_KHR_video_queue ===
1942 
1943  //=== VK_KHR_video_decode_queue ===
1945 
1946  //=== VK_EXT_transform_feedback ===
1953 
1954  //=== VK_NVX_binary_import ===
1960 
1961  //=== VK_NVX_image_view_handle ===
1964 
1965  //=== VK_AMD_draw_indirect_count ===
1968 
1969  //=== VK_AMD_shader_info ===
1971 
1972  //=== VK_KHR_dynamic_rendering ===
1975 
1976 # if defined( VK_USE_PLATFORM_WIN32_KHR )
1977  //=== VK_NV_external_memory_win32 ===
1978  PFN_vkGetMemoryWin32HandleNV vkGetMemoryWin32HandleNV = 0;
1979 # else
1980  PFN_dummy vkGetMemoryWin32HandleNV_placeholder = 0;
1981 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
1982 
1983  //=== VK_KHR_device_group ===
1987 
1988  //=== VK_KHR_maintenance1 ===
1990 
1991 # if defined( VK_USE_PLATFORM_WIN32_KHR )
1992  //=== VK_KHR_external_memory_win32 ===
1993  PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR = 0;
1994  PFN_vkGetMemoryWin32HandlePropertiesKHR vkGetMemoryWin32HandlePropertiesKHR = 0;
1995 # else
1996  PFN_dummy vkGetMemoryWin32HandleKHR_placeholder = 0;
1997  PFN_dummy vkGetMemoryWin32HandlePropertiesKHR_placeholder = 0;
1998 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
1999 
2000  //=== VK_KHR_external_memory_fd ===
2003 
2004 # if defined( VK_USE_PLATFORM_WIN32_KHR )
2005  //=== VK_KHR_external_semaphore_win32 ===
2006  PFN_vkImportSemaphoreWin32HandleKHR vkImportSemaphoreWin32HandleKHR = 0;
2007  PFN_vkGetSemaphoreWin32HandleKHR vkGetSemaphoreWin32HandleKHR = 0;
2008 # else
2009  PFN_dummy vkImportSemaphoreWin32HandleKHR_placeholder = 0;
2010  PFN_dummy vkGetSemaphoreWin32HandleKHR_placeholder = 0;
2011 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
2012 
2013  //=== VK_KHR_external_semaphore_fd ===
2016 
2017  //=== VK_KHR_push_descriptor ===
2020 
2021  //=== VK_EXT_conditional_rendering ===
2024 
2025  //=== VK_KHR_descriptor_update_template ===
2029 
2030  //=== VK_NV_clip_space_w_scaling ===
2032 
2033  //=== VK_EXT_display_control ===
2038 
2039  //=== VK_GOOGLE_display_timing ===
2042 
2043  //=== VK_EXT_discard_rectangles ===
2047 
2048  //=== VK_EXT_hdr_metadata ===
2050 
2051  //=== VK_KHR_create_renderpass2 ===
2056 
2057  //=== VK_KHR_shared_presentable_image ===
2059 
2060 # if defined( VK_USE_PLATFORM_WIN32_KHR )
2061  //=== VK_KHR_external_fence_win32 ===
2062  PFN_vkImportFenceWin32HandleKHR vkImportFenceWin32HandleKHR = 0;
2063  PFN_vkGetFenceWin32HandleKHR vkGetFenceWin32HandleKHR = 0;
2064 # else
2065  PFN_dummy vkImportFenceWin32HandleKHR_placeholder = 0;
2066  PFN_dummy vkGetFenceWin32HandleKHR_placeholder = 0;
2067 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
2068 
2069  //=== VK_KHR_external_fence_fd ===
2072 
2073  //=== VK_KHR_performance_query ===
2076 
2077  //=== VK_EXT_debug_utils ===
2086 
2087 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
2088  //=== VK_ANDROID_external_memory_android_hardware_buffer ===
2089  PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID = 0;
2090  PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID = 0;
2091 # else
2092  PFN_dummy vkGetAndroidHardwareBufferPropertiesANDROID_placeholder = 0;
2093  PFN_dummy vkGetMemoryAndroidHardwareBufferANDROID_placeholder = 0;
2094 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
2095 
2096 # if defined( VK_ENABLE_BETA_EXTENSIONS )
2097  //=== VK_AMDX_shader_enqueue ===
2098  PFN_vkCreateExecutionGraphPipelinesAMDX vkCreateExecutionGraphPipelinesAMDX = 0;
2099  PFN_vkGetExecutionGraphPipelineScratchSizeAMDX vkGetExecutionGraphPipelineScratchSizeAMDX = 0;
2100  PFN_vkGetExecutionGraphPipelineNodeIndexAMDX vkGetExecutionGraphPipelineNodeIndexAMDX = 0;
2101  PFN_vkCmdInitializeGraphScratchMemoryAMDX vkCmdInitializeGraphScratchMemoryAMDX = 0;
2102  PFN_vkCmdDispatchGraphAMDX vkCmdDispatchGraphAMDX = 0;
2103  PFN_vkCmdDispatchGraphIndirectAMDX vkCmdDispatchGraphIndirectAMDX = 0;
2104  PFN_vkCmdDispatchGraphIndirectCountAMDX vkCmdDispatchGraphIndirectCountAMDX = 0;
2105 # else
2106  PFN_dummy vkCreateExecutionGraphPipelinesAMDX_placeholder = 0;
2107  PFN_dummy vkGetExecutionGraphPipelineScratchSizeAMDX_placeholder = 0;
2108  PFN_dummy vkGetExecutionGraphPipelineNodeIndexAMDX_placeholder = 0;
2109  PFN_dummy vkCmdInitializeGraphScratchMemoryAMDX_placeholder = 0;
2110  PFN_dummy vkCmdDispatchGraphAMDX_placeholder = 0;
2111  PFN_dummy vkCmdDispatchGraphIndirectAMDX_placeholder = 0;
2112  PFN_dummy vkCmdDispatchGraphIndirectCountAMDX_placeholder = 0;
2113 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
2114 
2115  //=== VK_EXT_sample_locations ===
2117 
2118  //=== VK_KHR_get_memory_requirements2 ===
2122 
2123  //=== VK_KHR_acceleration_structure ===
2140 
2141  //=== VK_KHR_ray_tracing_pipeline ===
2149 
2150  //=== VK_KHR_sampler_ycbcr_conversion ===
2153 
2154  //=== VK_KHR_bind_memory2 ===
2157 
2158  //=== VK_EXT_image_drm_format_modifier ===
2160 
2161  //=== VK_EXT_validation_cache ===
2166 
2167  //=== VK_NV_shading_rate_image ===
2171 
2172  //=== VK_NV_ray_tracing ===
2185 
2186  //=== VK_KHR_maintenance3 ===
2188 
2189  //=== VK_KHR_draw_indirect_count ===
2192 
2193  //=== VK_EXT_external_memory_host ===
2195 
2196  //=== VK_AMD_buffer_marker ===
2198 
2199  //=== VK_EXT_calibrated_timestamps ===
2201 
2202  //=== VK_NV_mesh_shader ===
2206 
2207  //=== VK_NV_scissor_exclusive ===
2210 
2211  //=== VK_NV_device_diagnostic_checkpoints ===
2214 
2215  //=== VK_KHR_timeline_semaphore ===
2219 
2220  //=== VK_INTEL_performance_query ===
2230 
2231  //=== VK_AMD_display_native_hdr ===
2233 
2234  //=== VK_KHR_fragment_shading_rate ===
2236 
2237  //=== VK_EXT_buffer_device_address ===
2239 
2240  //=== VK_KHR_present_wait ===
2242 
2243 # if defined( VK_USE_PLATFORM_WIN32_KHR )
2244  //=== VK_EXT_full_screen_exclusive ===
2245  PFN_vkAcquireFullScreenExclusiveModeEXT vkAcquireFullScreenExclusiveModeEXT = 0;
2246  PFN_vkReleaseFullScreenExclusiveModeEXT vkReleaseFullScreenExclusiveModeEXT = 0;
2247  PFN_vkGetDeviceGroupSurfacePresentModes2EXT vkGetDeviceGroupSurfacePresentModes2EXT = 0;
2248 # else
2249  PFN_dummy vkAcquireFullScreenExclusiveModeEXT_placeholder = 0;
2250  PFN_dummy vkReleaseFullScreenExclusiveModeEXT_placeholder = 0;
2251  PFN_dummy vkGetDeviceGroupSurfacePresentModes2EXT_placeholder = 0;
2252 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
2253 
2254  //=== VK_KHR_buffer_device_address ===
2258 
2259  //=== VK_EXT_line_rasterization ===
2261 
2262  //=== VK_EXT_host_query_reset ===
2264 
2265  //=== VK_EXT_extended_dynamic_state ===
2278 
2279  //=== VK_KHR_deferred_host_operations ===
2285 
2286  //=== VK_KHR_pipeline_executable_properties ===
2290 
2291  //=== VK_EXT_host_image_copy ===
2297 
2298  //=== VK_KHR_map_memory2 ===
2301 
2302  //=== VK_EXT_swapchain_maintenance1 ===
2304 
2305  //=== VK_NV_device_generated_commands ===
2312 
2313  //=== VK_EXT_depth_bias_control ===
2315 
2316  //=== VK_EXT_private_data ===
2321 
2322  //=== VK_KHR_video_encode_queue ===
2325 
2326 # if defined( VK_ENABLE_BETA_EXTENSIONS )
2327  //=== VK_NV_cuda_kernel_launch ===
2334 # else
2335  PFN_dummy vkCreateCudaModuleNV_placeholder = 0;
2336  PFN_dummy vkGetCudaModuleCacheNV_placeholder = 0;
2337  PFN_dummy vkCreateCudaFunctionNV_placeholder = 0;
2338  PFN_dummy vkDestroyCudaModuleNV_placeholder = 0;
2339  PFN_dummy vkDestroyCudaFunctionNV_placeholder = 0;
2340  PFN_dummy vkCmdCudaLaunchKernelNV_placeholder = 0;
2341 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
2342 
2343 # if defined( VK_USE_PLATFORM_METAL_EXT )
2344  //=== VK_EXT_metal_objects ===
2345  PFN_vkExportMetalObjectsEXT vkExportMetalObjectsEXT = 0;
2346 # else
2347  PFN_dummy vkExportMetalObjectsEXT_placeholder = 0;
2348 # endif /*VK_USE_PLATFORM_METAL_EXT*/
2349 
2350  //=== VK_KHR_synchronization2 ===
2359 
2360  //=== VK_EXT_descriptor_buffer ===
2372 
2373  //=== VK_NV_fragment_shading_rate_enums ===
2375 
2376  //=== VK_EXT_mesh_shader ===
2380 
2381  //=== VK_KHR_copy_commands2 ===
2388 
2389  //=== VK_EXT_device_fault ===
2391 
2392  //=== VK_EXT_vertex_input_dynamic_state ===
2394 
2395 # if defined( VK_USE_PLATFORM_FUCHSIA )
2396  //=== VK_FUCHSIA_external_memory ===
2397  PFN_vkGetMemoryZirconHandleFUCHSIA vkGetMemoryZirconHandleFUCHSIA = 0;
2398  PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA vkGetMemoryZirconHandlePropertiesFUCHSIA = 0;
2399 # else
2400  PFN_dummy vkGetMemoryZirconHandleFUCHSIA_placeholder = 0;
2401  PFN_dummy vkGetMemoryZirconHandlePropertiesFUCHSIA_placeholder = 0;
2402 # endif /*VK_USE_PLATFORM_FUCHSIA*/
2403 
2404 # if defined( VK_USE_PLATFORM_FUCHSIA )
2405  //=== VK_FUCHSIA_external_semaphore ===
2406  PFN_vkImportSemaphoreZirconHandleFUCHSIA vkImportSemaphoreZirconHandleFUCHSIA = 0;
2407  PFN_vkGetSemaphoreZirconHandleFUCHSIA vkGetSemaphoreZirconHandleFUCHSIA = 0;
2408 # else
2409  PFN_dummy vkImportSemaphoreZirconHandleFUCHSIA_placeholder = 0;
2410  PFN_dummy vkGetSemaphoreZirconHandleFUCHSIA_placeholder = 0;
2411 # endif /*VK_USE_PLATFORM_FUCHSIA*/
2412 
2413 # if defined( VK_USE_PLATFORM_FUCHSIA )
2414  //=== VK_FUCHSIA_buffer_collection ===
2415  PFN_vkCreateBufferCollectionFUCHSIA vkCreateBufferCollectionFUCHSIA = 0;
2416  PFN_vkSetBufferCollectionImageConstraintsFUCHSIA vkSetBufferCollectionImageConstraintsFUCHSIA = 0;
2417  PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA vkSetBufferCollectionBufferConstraintsFUCHSIA = 0;
2418  PFN_vkDestroyBufferCollectionFUCHSIA vkDestroyBufferCollectionFUCHSIA = 0;
2419  PFN_vkGetBufferCollectionPropertiesFUCHSIA vkGetBufferCollectionPropertiesFUCHSIA = 0;
2420 # else
2421  PFN_dummy vkCreateBufferCollectionFUCHSIA_placeholder = 0;
2422  PFN_dummy vkSetBufferCollectionImageConstraintsFUCHSIA_placeholder = 0;
2423  PFN_dummy vkSetBufferCollectionBufferConstraintsFUCHSIA_placeholder = 0;
2424  PFN_dummy vkDestroyBufferCollectionFUCHSIA_placeholder = 0;
2425  PFN_dummy vkGetBufferCollectionPropertiesFUCHSIA_placeholder = 0;
2426 # endif /*VK_USE_PLATFORM_FUCHSIA*/
2427 
2428  //=== VK_HUAWEI_subpass_shading ===
2431 
2432  //=== VK_HUAWEI_invocation_mask ===
2434 
2435  //=== VK_NV_external_memory_rdma ===
2437 
2438  //=== VK_EXT_pipeline_properties ===
2440 
2441  //=== VK_EXT_extended_dynamic_state2 ===
2447 
2448  //=== VK_EXT_color_write_enable ===
2450 
2451  //=== VK_KHR_ray_tracing_maintenance1 ===
2453 
2454  //=== VK_EXT_multi_draw ===
2457 
2458  //=== VK_EXT_opacity_micromap ===
2473 
2474  //=== VK_HUAWEI_cluster_culling_shader ===
2477 
2478  //=== VK_EXT_pageable_device_local_memory ===
2480 
2481  //=== VK_KHR_maintenance4 ===
2485 
2486  //=== VK_VALVE_descriptor_set_host_mapping ===
2489 
2490  //=== VK_NV_copy_memory_indirect ===
2493 
2494  //=== VK_NV_memory_decompression ===
2497 
2498  //=== VK_NV_device_generated_commands_compute ===
2502 
2503  //=== VK_EXT_extended_dynamic_state3 ===
2535 
2536  //=== VK_EXT_shader_module_identifier ===
2539 
2540  //=== VK_NV_optical_flow ===
2545 
2546  //=== VK_KHR_maintenance5 ===
2551 
2552  //=== VK_EXT_shader_object ===
2557 
2558  //=== VK_QCOM_tile_properties ===
2561 
2562  //=== VK_NV_low_latency2 ===
2568 
2569  //=== VK_EXT_attachment_feedback_loop_dynamic_state ===
2571 
2572 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
2573  //=== VK_QNX_external_memory_screen_buffer ===
2574  PFN_vkGetScreenBufferPropertiesQNX vkGetScreenBufferPropertiesQNX = 0;
2575 # else
2576  PFN_dummy vkGetScreenBufferPropertiesQNX_placeholder = 0;
2577 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/
2578 
2579  //=== VK_KHR_calibrated_timestamps ===
2581 
2582  //=== VK_KHR_maintenance6 ===
2589  };
2590 
2591  //========================================
2592  //=== RAII HANDLE forward declarations ===
2593  //========================================
2594 
2595  //=== VK_VERSION_1_0 ===
2596  class Instance;
2597  class PhysicalDevice;
2598  class Device;
2599  class Queue;
2600  class DeviceMemory;
2601  class Fence;
2602  class Semaphore;
2603  class Event;
2604  class QueryPool;
2605  class Buffer;
2606  class BufferView;
2607  class Image;
2608  class ImageView;
2609  class ShaderModule;
2610  class PipelineCache;
2611  class Pipeline;
2612  class PipelineLayout;
2613  class Sampler;
2614  class DescriptorPool;
2615  class DescriptorSet;
2616  class DescriptorSetLayout;
2617  class Framebuffer;
2618  class RenderPass;
2619  class CommandPool;
2620  class CommandBuffer;
2621 
2622  //=== VK_VERSION_1_1 ===
2623  class SamplerYcbcrConversion;
2625 
2626  //=== VK_VERSION_1_3 ===
2627  class PrivateDataSlot;
2628 
2629  //=== VK_KHR_surface ===
2630  class SurfaceKHR;
2631 
2632  //=== VK_KHR_swapchain ===
2633  class SwapchainKHR;
2634 
2635  //=== VK_KHR_display ===
2636  class DisplayKHR;
2637  class DisplayModeKHR;
2638 
2639  //=== VK_EXT_debug_report ===
2640  class DebugReportCallbackEXT;
2641 
2642  //=== VK_KHR_video_queue ===
2643  class VideoSessionKHR;
2645 
2646  //=== VK_NVX_binary_import ===
2647  class CuModuleNVX;
2648  class CuFunctionNVX;
2649 
2650  //=== VK_EXT_debug_utils ===
2651  class DebugUtilsMessengerEXT;
2652 
2653  //=== VK_KHR_acceleration_structure ===
2655 
2656  //=== VK_EXT_validation_cache ===
2657  class ValidationCacheEXT;
2658 
2659  //=== VK_NV_ray_tracing ===
2661 
2662  //=== VK_INTEL_performance_query ===
2664 
2665  //=== VK_KHR_deferred_host_operations ===
2666  class DeferredOperationKHR;
2667 
2668  //=== VK_NV_device_generated_commands ===
2670 
2671 # if defined( VK_ENABLE_BETA_EXTENSIONS )
2672  //=== VK_NV_cuda_kernel_launch ===
2673  class CudaModuleNV;
2674  class CudaFunctionNV;
2675 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
2676 
2677 # if defined( VK_USE_PLATFORM_FUCHSIA )
2678  //=== VK_FUCHSIA_buffer_collection ===
2679  class BufferCollectionFUCHSIA;
2680 # endif /*VK_USE_PLATFORM_FUCHSIA*/
2681 
2682  //=== VK_EXT_opacity_micromap ===
2683  class MicromapEXT;
2684 
2685  //=== VK_NV_optical_flow ===
2686  class OpticalFlowSessionNV;
2687 
2688  //=== VK_EXT_shader_object ===
2689  class ShaderEXT;
2690 
2691  //====================
2692  //=== RAII HANDLES ===
2693  //====================
2694 
2695  class Context
2696  {
2697  public:
2698 # if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
2699  Context()
2700  : m_dispatcher( new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher(
2701  m_dynamicLoader.getProcAddress<PFN_vkGetInstanceProcAddr>( "vkGetInstanceProcAddr" ) ) )
2702 # else
2703  Context( PFN_vkGetInstanceProcAddr getInstanceProcAddr )
2704  : m_dispatcher( new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher( getInstanceProcAddr ) )
2705 # endif
2706  {
2707  }
2708 
2709  ~Context() = default;
2710 
2711  Context( Context const & ) = delete;
2713 # if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
2714  : m_dynamicLoader( std::move( rhs.m_dynamicLoader ) )
2715  , m_dispatcher( rhs.m_dispatcher.release() )
2716 # else
2717  : m_dispatcher( rhs.m_dispatcher.release() )
2718 # endif
2719  {
2720  }
2721  Context & operator=( Context const & ) = delete;
2722 
2724  {
2725  if ( this != &rhs )
2726  {
2727 # if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
2728  m_dynamicLoader = std::move( rhs.m_dynamicLoader );
2729 # endif
2730  m_dispatcher.reset( rhs.m_dispatcher.release() );
2731  }
2732  return *this;
2733  }
2734 
2735  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher const * getDispatcher() const
2736  {
2737  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
2738  return &*m_dispatcher;
2739  }
2740 
2741  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Context & rhs )
2742  {
2743 # if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
2744  std::swap( m_dynamicLoader, rhs.m_dynamicLoader );
2745 # endif
2746  m_dispatcher.swap( rhs.m_dispatcher );
2747  }
2748 
2749  //=== VK_VERSION_1_0 ===
2750 
2751  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance>::Type
2752  createInstance( VULKAN_HPP_NAMESPACE::InstanceCreateInfo const & createInfo,
2753  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
2755 
2756  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties>
2758 
2759  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::LayerProperties> enumerateInstanceLayerProperties() const;
2760 
2761  //=== VK_VERSION_1_1 ===
2762 
2764 
2765  private:
2766 # if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL
2767  VULKAN_HPP_NAMESPACE::DynamicLoader m_dynamicLoader;
2768 # endif
2769  std::unique_ptr<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ContextDispatcher> m_dispatcher;
2770  };
2771 
2772  class Instance
2773  {
2774  public:
2777 
2778  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eInstance;
2780  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eInstance;
2781 
2782  public:
2783 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
2784  Instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Context const & context,
2785  VULKAN_HPP_NAMESPACE::InstanceCreateInfo const & createInfo,
2786  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
2787  {
2788  *this = context.createInstance( createInfo, allocator );
2789  }
2790 # endif
2791 
2792  Instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Context const & context,
2793  VkInstance instance,
2794  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
2795  : m_instance( instance ), m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
2796  {
2797  m_dispatcher.reset( new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher( context.getDispatcher()->vkGetInstanceProcAddr,
2798  static_cast<VkInstance>( m_instance ) ) );
2799  }
2800 
2801  Instance( std::nullptr_t ) {}
2802 
2804  {
2805  clear();
2806  }
2807 
2808  Instance() = delete;
2809  Instance( Instance const & ) = delete;
2810 
2812  : m_instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} ) )
2813  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
2814  , m_dispatcher( rhs.m_dispatcher.release() )
2815  {
2816  }
2817 
2818  Instance & operator=( Instance const & ) = delete;
2819 
2821  {
2822  if ( this != &rhs )
2823  {
2824  std::swap( m_instance, rhs.m_instance );
2825  std::swap( m_allocator, rhs.m_allocator );
2826  std::swap( m_dispatcher, rhs.m_dispatcher );
2827  }
2828  return *this;
2829  }
2830 
2831  VULKAN_HPP_NAMESPACE::Instance const & operator*() const VULKAN_HPP_NOEXCEPT
2832  {
2833  return m_instance;
2834  }
2835 
2836  operator VULKAN_HPP_NAMESPACE::Instance() const VULKAN_HPP_NOEXCEPT
2837  {
2838  return m_instance;
2839  }
2840 
2842  {
2843  if ( m_instance )
2844  {
2845  getDispatcher()->vkDestroyInstance( static_cast<VkInstance>( m_instance ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
2846  }
2847  m_instance = nullptr;
2848  m_allocator = nullptr;
2849  m_dispatcher = nullptr;
2850  }
2851 
2852  VULKAN_HPP_NAMESPACE::Instance release()
2853  {
2854  m_allocator = nullptr;
2855  m_dispatcher = nullptr;
2856  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_instance, nullptr );
2857  }
2858 
2859  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const
2860  {
2861  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
2862  return &*m_dispatcher;
2863  }
2864 
2865  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance & rhs ) VULKAN_HPP_NOEXCEPT
2866  {
2867  std::swap( m_instance, rhs.m_instance );
2868  std::swap( m_allocator, rhs.m_allocator );
2869  std::swap( m_dispatcher, rhs.m_dispatcher );
2870  }
2871 
2872  //=== VK_VERSION_1_0 ===
2873 
2875  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice>>::Type
2876  enumeratePhysicalDevices() const;
2877 
2878  VULKAN_HPP_NODISCARD PFN_vkVoidFunction getProcAddr( const std::string & name ) const VULKAN_HPP_NOEXCEPT;
2879 
2880  //=== VK_VERSION_1_1 ===
2881 
2882  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> enumeratePhysicalDeviceGroups() const;
2883 
2884  //=== VK_KHR_display ===
2885 
2886  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type
2887  createDisplayPlaneSurfaceKHR( VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR const & createInfo,
2888  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
2890 
2891 # if defined( VK_USE_PLATFORM_XLIB_KHR )
2892  //=== VK_KHR_xlib_surface ===
2893 
2894  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type
2895  createXlibSurfaceKHR( VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR const & createInfo,
2896  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
2898 # endif /*VK_USE_PLATFORM_XLIB_KHR*/
2899 
2900 # if defined( VK_USE_PLATFORM_XCB_KHR )
2901  //=== VK_KHR_xcb_surface ===
2902 
2903  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type
2904  createXcbSurfaceKHR( VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR const & createInfo,
2905  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
2907 # endif /*VK_USE_PLATFORM_XCB_KHR*/
2908 
2909 # if defined( VK_USE_PLATFORM_WAYLAND_KHR )
2910  //=== VK_KHR_wayland_surface ===
2911 
2912  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type
2913  createWaylandSurfaceKHR( VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR const & createInfo,
2914  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
2916 # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
2917 
2918 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
2919  //=== VK_KHR_android_surface ===
2920 
2921  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type
2922  createAndroidSurfaceKHR( VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR const & createInfo,
2923  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
2925 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
2926 
2927 # if defined( VK_USE_PLATFORM_WIN32_KHR )
2928  //=== VK_KHR_win32_surface ===
2929 
2930  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type
2931  createWin32SurfaceKHR( VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR const & createInfo,
2932  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
2934 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
2935 
2936  //=== VK_EXT_debug_report ===
2937 
2939  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DebugReportCallbackEXT>::Type
2940  createDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT const & createInfo,
2941  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
2943 
2944  void debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags,
2945  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT objectType_,
2946  uint64_t object,
2947  size_t location,
2948  int32_t messageCode,
2949  const std::string & layerPrefix,
2950  const std::string & message ) const VULKAN_HPP_NOEXCEPT;
2951 
2952 # if defined( VK_USE_PLATFORM_GGP )
2953  //=== VK_GGP_stream_descriptor_surface ===
2954 
2955  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type
2956  createStreamDescriptorSurfaceGGP( VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP const & createInfo,
2957  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
2959 # endif /*VK_USE_PLATFORM_GGP*/
2960 
2961 # if defined( VK_USE_PLATFORM_VI_NN )
2962  //=== VK_NN_vi_surface ===
2963 
2964  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type
2965  createViSurfaceNN( VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN const & createInfo,
2966  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
2968 # endif /*VK_USE_PLATFORM_VI_NN*/
2969 
2970  //=== VK_KHR_device_group_creation ===
2971 
2972  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> enumeratePhysicalDeviceGroupsKHR() const;
2973 
2974 # if defined( VK_USE_PLATFORM_IOS_MVK )
2975  //=== VK_MVK_ios_surface ===
2976 
2977  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type
2978  createIOSSurfaceMVK( VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK const & createInfo,
2979  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
2981 # endif /*VK_USE_PLATFORM_IOS_MVK*/
2982 
2983 # if defined( VK_USE_PLATFORM_MACOS_MVK )
2984  //=== VK_MVK_macos_surface ===
2985 
2986  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type
2987  createMacOSSurfaceMVK( VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK const & createInfo,
2988  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
2990 # endif /*VK_USE_PLATFORM_MACOS_MVK*/
2991 
2992  //=== VK_EXT_debug_utils ===
2993 
2995  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DebugUtilsMessengerEXT>::Type
2996  createDebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT const & createInfo,
2997  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
2999 
3000  void submitDebugUtilsMessageEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
3001  VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT messageTypes,
3002  const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT & callbackData ) const VULKAN_HPP_NOEXCEPT;
3003 
3004 # if defined( VK_USE_PLATFORM_FUCHSIA )
3005  //=== VK_FUCHSIA_imagepipe_surface ===
3006 
3007  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type
3008  createImagePipeSurfaceFUCHSIA( VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA const & createInfo,
3009  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3011 # endif /*VK_USE_PLATFORM_FUCHSIA*/
3012 
3013 # if defined( VK_USE_PLATFORM_METAL_EXT )
3014  //=== VK_EXT_metal_surface ===
3015 
3016  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type
3017  createMetalSurfaceEXT( VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT const & createInfo,
3018  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3020 # endif /*VK_USE_PLATFORM_METAL_EXT*/
3021 
3022  //=== VK_EXT_headless_surface ===
3023 
3024  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type
3025  createHeadlessSurfaceEXT( VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT const & createInfo,
3026  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3028 
3029 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
3030  //=== VK_EXT_directfb_surface ===
3031 
3032  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type
3033  createDirectFBSurfaceEXT( VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT const & createInfo,
3034  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3036 # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
3037 
3038 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
3039  //=== VK_QNX_screen_surface ===
3040 
3041  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type
3042  createScreenSurfaceQNX( VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const & createInfo,
3043  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3045 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/
3046 
3047  private:
3048  VULKAN_HPP_NAMESPACE::Instance m_instance = {};
3049  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
3050  std::unique_ptr<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher> m_dispatcher;
3051  };
3052 
3054  {
3055  public:
3058 
3059  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePhysicalDevice;
3061  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePhysicalDevice;
3062 
3063  public:
3064  PhysicalDevice( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance, VkPhysicalDevice physicalDevice )
3065  : m_physicalDevice( physicalDevice ), m_dispatcher( instance.getDispatcher() )
3066  {
3067  }
3068 
3069  PhysicalDevice( std::nullptr_t ) {}
3070 
3072  {
3073  clear();
3074  }
3075 
3076  PhysicalDevice() = delete;
3077 
3078  PhysicalDevice( PhysicalDevice const & rhs ) : m_physicalDevice( rhs.m_physicalDevice ), m_dispatcher( rhs.m_dispatcher ) {}
3079 
3081  : m_physicalDevice( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} ) )
3082  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
3083  {
3084  }
3085 
3087  {
3088  m_physicalDevice = rhs.m_physicalDevice;
3089  m_dispatcher = rhs.m_dispatcher;
3090  return *this;
3091  }
3092 
3094  {
3095  if ( this != &rhs )
3096  {
3097  std::swap( m_physicalDevice, rhs.m_physicalDevice );
3098  std::swap( m_dispatcher, rhs.m_dispatcher );
3099  }
3100  return *this;
3101  }
3102 
3103  VULKAN_HPP_NAMESPACE::PhysicalDevice const & operator*() const VULKAN_HPP_NOEXCEPT
3104  {
3105  return m_physicalDevice;
3106  }
3107 
3108  operator VULKAN_HPP_NAMESPACE::PhysicalDevice() const VULKAN_HPP_NOEXCEPT
3109  {
3110  return m_physicalDevice;
3111  }
3112 
3114  {
3115  m_physicalDevice = nullptr;
3116  m_dispatcher = nullptr;
3117  }
3118 
3119  VULKAN_HPP_NAMESPACE::PhysicalDevice release()
3120  {
3121  m_dispatcher = nullptr;
3122  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_physicalDevice, nullptr );
3123  }
3124 
3125  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const
3126  {
3127  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
3128  return m_dispatcher;
3129  }
3130 
3131  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice & rhs ) VULKAN_HPP_NOEXCEPT
3132  {
3133  std::swap( m_physicalDevice, rhs.m_physicalDevice );
3134  std::swap( m_dispatcher, rhs.m_dispatcher );
3135  }
3136 
3137  //=== VK_VERSION_1_0 ===
3138 
3139  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures getFeatures() const VULKAN_HPP_NOEXCEPT;
3140 
3141  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties getFormatProperties( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT;
3142 
3143  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ImageFormatProperties
3144  getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format,
3145  VULKAN_HPP_NAMESPACE::ImageType type,
3146  VULKAN_HPP_NAMESPACE::ImageTiling tiling,
3147  VULKAN_HPP_NAMESPACE::ImageUsageFlags usage,
3148  VULKAN_HPP_NAMESPACE::ImageCreateFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const;
3149 
3150  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties getProperties() const VULKAN_HPP_NOEXCEPT;
3151 
3152  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties> getQueueFamilyProperties() const;
3153 
3154  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties getMemoryProperties() const VULKAN_HPP_NOEXCEPT;
3155 
3156  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device>::Type
3157  createDevice( VULKAN_HPP_NAMESPACE::DeviceCreateInfo const & createInfo,
3158  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3160 
3161  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties>
3162  enumerateDeviceExtensionProperties( Optional<const std::string> layerName VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const;
3163 
3164  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::LayerProperties> enumerateDeviceLayerProperties() const;
3165 
3166  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>
3167  getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format,
3168  VULKAN_HPP_NAMESPACE::ImageType type,
3169  VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
3170  VULKAN_HPP_NAMESPACE::ImageUsageFlags usage,
3171  VULKAN_HPP_NAMESPACE::ImageTiling tiling ) const;
3172 
3173  //=== VK_VERSION_1_1 ===
3174 
3175  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 getFeatures2() const VULKAN_HPP_NOEXCEPT;
3176 
3177  template <typename X, typename Y, typename... Z>
3178  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getFeatures2() const VULKAN_HPP_NOEXCEPT;
3179 
3180  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 getProperties2() const VULKAN_HPP_NOEXCEPT;
3181 
3182  template <typename X, typename Y, typename... Z>
3183  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getProperties2() const VULKAN_HPP_NOEXCEPT;
3184 
3185  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2 getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT;
3186 
3187  template <typename X, typename Y, typename... Z>
3188  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
3189  getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT;
3190 
3191  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ImageFormatProperties2
3192  getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const;
3193 
3194  template <typename X, typename Y, typename... Z>
3195  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
3196  getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const;
3197 
3198  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> getQueueFamilyProperties2() const;
3199 
3200  template <typename StructureChain>
3201  VULKAN_HPP_NODISCARD std::vector<StructureChain> getQueueFamilyProperties2() const;
3202 
3203  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 getMemoryProperties2() const VULKAN_HPP_NOEXCEPT;
3204 
3205  template <typename X, typename Y, typename... Z>
3206  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getMemoryProperties2() const VULKAN_HPP_NOEXCEPT;
3207 
3208  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>
3209  getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo ) const;
3210 
3211  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties
3212  getExternalBufferProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo ) const VULKAN_HPP_NOEXCEPT;
3213 
3214  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties
3215  getExternalFenceProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo ) const VULKAN_HPP_NOEXCEPT;
3216 
3218  getExternalSemaphoreProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT;
3219 
3220  //=== VK_VERSION_1_3 ===
3221 
3222  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties> getToolProperties() const;
3223 
3224  //=== VK_KHR_surface ===
3225 
3226  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32 getSurfaceSupportKHR( uint32_t queueFamilyIndex, VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const;
3227 
3228  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const;
3229 
3230  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>
3231  getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const;
3232 
3233  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR>
3234  getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const;
3235 
3236  //=== VK_KHR_swapchain ===
3237 
3238  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::Rect2D> getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const;
3239 
3240  //=== VK_KHR_display ===
3241 
3242  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR> getDisplayPropertiesKHR() const;
3243 
3244  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR> getDisplayPlanePropertiesKHR() const;
3245 
3247  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR>>::Type
3248  getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex ) const;
3249 
3250 # if defined( VK_USE_PLATFORM_XLIB_KHR )
3251  //=== VK_KHR_xlib_surface ===
3252 
3254  getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID ) const VULKAN_HPP_NOEXCEPT;
3255 # endif /*VK_USE_PLATFORM_XLIB_KHR*/
3256 
3257 # if defined( VK_USE_PLATFORM_XCB_KHR )
3258  //=== VK_KHR_xcb_surface ===
3259 
3261  getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t & connection, xcb_visualid_t visual_id ) const VULKAN_HPP_NOEXCEPT;
3262 # endif /*VK_USE_PLATFORM_XCB_KHR*/
3263 
3264 # if defined( VK_USE_PLATFORM_WAYLAND_KHR )
3265  //=== VK_KHR_wayland_surface ===
3266 
3267  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex,
3268  struct wl_display & display ) const VULKAN_HPP_NOEXCEPT;
3269 # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
3270 
3271 # if defined( VK_USE_PLATFORM_WIN32_KHR )
3272  //=== VK_KHR_win32_surface ===
3273 
3274  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32 getWin32PresentationSupportKHR( uint32_t queueFamilyIndex ) const VULKAN_HPP_NOEXCEPT;
3275 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
3276 
3277  //=== VK_KHR_video_queue ===
3278 
3279  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR
3280  getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile ) const;
3281 
3282  template <typename X, typename Y, typename... Z>
3283  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
3284  getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile ) const;
3285 
3286  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>
3287  getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo ) const;
3288 
3289  //=== VK_NV_external_memory_capabilities ===
3290 
3291  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV getExternalImageFormatPropertiesNV(
3298 
3299  //=== VK_KHR_get_physical_device_properties2 ===
3300 
3301  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 getFeatures2KHR() const VULKAN_HPP_NOEXCEPT;
3302 
3303  template <typename X, typename Y, typename... Z>
3304  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getFeatures2KHR() const VULKAN_HPP_NOEXCEPT;
3305 
3306  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 getProperties2KHR() const VULKAN_HPP_NOEXCEPT;
3307 
3308  template <typename X, typename Y, typename... Z>
3309  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getProperties2KHR() const VULKAN_HPP_NOEXCEPT;
3310 
3311  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::FormatProperties2 getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT;
3312 
3313  template <typename X, typename Y, typename... Z>
3314  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
3315  getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT;
3316 
3317  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ImageFormatProperties2
3318  getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const;
3319 
3320  template <typename X, typename Y, typename... Z>
3321  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
3322  getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const;
3323 
3324  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> getQueueFamilyProperties2KHR() const;
3325 
3326  template <typename StructureChain>
3327  VULKAN_HPP_NODISCARD std::vector<StructureChain> getQueueFamilyProperties2KHR() const;
3328 
3329  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT;
3330 
3331  template <typename X, typename Y, typename... Z>
3332  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT;
3333 
3334  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>
3335  getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo ) const;
3336 
3337  //=== VK_KHR_external_memory_capabilities ===
3338 
3339  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalBufferProperties
3340  getExternalBufferPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo ) const VULKAN_HPP_NOEXCEPT;
3341 
3342  //=== VK_KHR_external_semaphore_capabilities ===
3343 
3345  getExternalSemaphorePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT;
3346 
3347 # if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
3348  //=== VK_EXT_acquire_xlib_display ===
3349 
3350  void acquireXlibDisplayEXT( Display & dpy, VULKAN_HPP_NAMESPACE::DisplayKHR display ) const;
3351 
3352  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR>::Type
3353  getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT;
3354 # endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
3355 
3356  //=== VK_EXT_display_surface_counter ===
3357 
3358  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const;
3359 
3360  //=== VK_KHR_external_fence_capabilities ===
3361 
3362  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExternalFenceProperties
3363  getExternalFencePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo ) const VULKAN_HPP_NOEXCEPT;
3364 
3365  //=== VK_KHR_performance_query ===
3366 
3368  std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>, std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>>
3369  enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex ) const;
3370 
3371  VULKAN_HPP_NODISCARD uint32_t getQueueFamilyPerformanceQueryPassesKHR(
3372  const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo ) const VULKAN_HPP_NOEXCEPT;
3373 
3374  //=== VK_KHR_get_surface_capabilities2 ===
3375 
3376  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR
3377  getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const;
3378 
3379  template <typename X, typename Y, typename... Z>
3380  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
3381  getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const;
3382 
3383  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>
3384  getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const;
3385 
3386  template <typename StructureChain>
3387  VULKAN_HPP_NODISCARD std::vector<StructureChain> getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const;
3388 
3389  //=== VK_KHR_get_display_properties2 ===
3390 
3391  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR> getDisplayProperties2KHR() const;
3392 
3393  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR> getDisplayPlaneProperties2KHR() const;
3394 
3395  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR
3396  getDisplayPlaneCapabilities2KHR( const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR & displayPlaneInfo ) const;
3397 
3398  //=== VK_EXT_sample_locations ===
3399 
3400  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT
3401  getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples ) const VULKAN_HPP_NOEXCEPT;
3402 
3403  //=== VK_EXT_calibrated_timestamps ===
3404 
3405  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR> getCalibrateableTimeDomainsEXT() const;
3406 
3407  //=== VK_KHR_fragment_shading_rate ===
3408 
3409  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR> getFragmentShadingRatesKHR() const;
3410 
3411  //=== VK_EXT_tooling_info ===
3412 
3413  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties> getToolPropertiesEXT() const;
3414 
3415  //=== VK_NV_cooperative_matrix ===
3416 
3417  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV> getCooperativeMatrixPropertiesNV() const;
3418 
3419  //=== VK_NV_coverage_reduction_mode ===
3420 
3421  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV> getSupportedFramebufferMixedSamplesCombinationsNV() const;
3422 
3423 # if defined( VK_USE_PLATFORM_WIN32_KHR )
3424  //=== VK_EXT_full_screen_exclusive ===
3425 
3426  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR>
3427  getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const;
3428 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
3429 
3430  //=== VK_EXT_acquire_drm_display ===
3431 
3432  void acquireDrmDisplayEXT( int32_t drmFd, VULKAN_HPP_NAMESPACE::DisplayKHR display ) const;
3433 
3434  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR>::Type
3435  getDrmDisplayEXT( int32_t drmFd, uint32_t connectorId ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT;
3436 
3437  //=== VK_KHR_video_encode_queue ===
3438 
3439  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR
3440  getVideoEncodeQualityLevelPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo ) const;
3441 
3442  template <typename X, typename Y, typename... Z>
3443  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
3444  getVideoEncodeQualityLevelPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo ) const;
3445 
3446 # if defined( VK_USE_PLATFORM_WIN32_KHR )
3447  //=== VK_NV_acquire_winrt_display ===
3448 
3449  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR>::Type
3450  getWinrtDisplayNV( uint32_t deviceRelativeId ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT;
3451 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
3452 
3453 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
3454  //=== VK_EXT_directfb_surface ===
3455 
3456  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32 getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex,
3457  IDirectFB & dfb ) const VULKAN_HPP_NOEXCEPT;
3458 # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
3459 
3460 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
3461  //=== VK_QNX_screen_surface ===
3462 
3463  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Bool32 getScreenPresentationSupportQNX( uint32_t queueFamilyIndex,
3464  struct _screen_window & window ) const VULKAN_HPP_NOEXCEPT;
3465 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/
3466 
3467  //=== VK_NV_optical_flow ===
3468 
3469  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>
3470  getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo ) const;
3471 
3472  //=== VK_KHR_cooperative_matrix ===
3473 
3474  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR> getCooperativeMatrixPropertiesKHR() const;
3475 
3476  //=== VK_KHR_calibrated_timestamps ===
3477 
3478  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR> getCalibrateableTimeDomainsKHR() const;
3479 
3480  private:
3481  VULKAN_HPP_NAMESPACE::PhysicalDevice m_physicalDevice = {};
3482  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr;
3483  };
3484 
3485  class PhysicalDevices : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice>
3486  {
3487  public:
3488 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
3489  PhysicalDevices( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance )
3490  {
3491  *this = instance.enumeratePhysicalDevices();
3492  }
3493 # endif
3494 
3495  PhysicalDevices( std::nullptr_t ) {}
3496 
3497  PhysicalDevices() = delete;
3498  PhysicalDevices( PhysicalDevices const & ) = delete;
3499  PhysicalDevices( PhysicalDevices && rhs ) = default;
3502 
3503  private:
3504  PhysicalDevices( std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice> && rhs )
3505  {
3506  std::swap( *this, rhs );
3507  }
3508  };
3509 
3510  class Device
3511  {
3512  public:
3513  using CType = VkDevice;
3515 
3516  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDevice;
3518  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDevice;
3519 
3520  public:
3521 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
3522  Device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice,
3523  VULKAN_HPP_NAMESPACE::DeviceCreateInfo const & createInfo,
3524  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
3525  {
3526  *this = physicalDevice.createDevice( createInfo, allocator );
3527  }
3528 # endif
3529 
3530  Device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice,
3531  VkDevice device,
3532  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
3533  : m_device( device ), m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
3534  {
3535  m_dispatcher.reset( new VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher( physicalDevice.getDispatcher()->vkGetDeviceProcAddr,
3536  static_cast<VkDevice>( m_device ) ) );
3537  }
3538 
3539  Device( std::nullptr_t ) {}
3540 
3542  {
3543  clear();
3544  }
3545 
3546  Device() = delete;
3547  Device( Device const & ) = delete;
3548 
3550  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
3551  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
3552  , m_dispatcher( rhs.m_dispatcher.release() )
3553  {
3554  }
3555 
3556  Device & operator=( Device const & ) = delete;
3557 
3559  {
3560  if ( this != &rhs )
3561  {
3562  std::swap( m_device, rhs.m_device );
3563  std::swap( m_allocator, rhs.m_allocator );
3564  std::swap( m_dispatcher, rhs.m_dispatcher );
3565  }
3566  return *this;
3567  }
3568 
3569  VULKAN_HPP_NAMESPACE::Device const & operator*() const VULKAN_HPP_NOEXCEPT
3570  {
3571  return m_device;
3572  }
3573 
3574  operator VULKAN_HPP_NAMESPACE::Device() const VULKAN_HPP_NOEXCEPT
3575  {
3576  return m_device;
3577  }
3578 
3580  {
3581  if ( m_device )
3582  {
3583  getDispatcher()->vkDestroyDevice( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
3584  }
3585  m_device = nullptr;
3586  m_allocator = nullptr;
3587  m_dispatcher = nullptr;
3588  }
3589 
3590  VULKAN_HPP_NAMESPACE::Device release()
3591  {
3592  m_allocator = nullptr;
3593  m_dispatcher = nullptr;
3595  }
3596 
3597  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
3598  {
3599  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
3600  return &*m_dispatcher;
3601  }
3602 
3603  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device & rhs ) VULKAN_HPP_NOEXCEPT
3604  {
3605  std::swap( m_device, rhs.m_device );
3606  std::swap( m_allocator, rhs.m_allocator );
3607  std::swap( m_dispatcher, rhs.m_dispatcher );
3608  }
3609 
3610  //=== VK_VERSION_1_0 ===
3611 
3612  VULKAN_HPP_NODISCARD PFN_vkVoidFunction getProcAddr( const std::string & name ) const VULKAN_HPP_NOEXCEPT;
3613 
3614  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Queue>::Type
3615  getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT;
3616 
3617  void waitIdle() const;
3618 
3620  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceMemory>::Type
3621  allocateMemory( VULKAN_HPP_NAMESPACE::MemoryAllocateInfo const & allocateInfo,
3622  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3624 
3625  void flushMappedMemoryRanges( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges ) const;
3626 
3627  void invalidateMappedMemoryRanges( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges ) const;
3628 
3629  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Fence>::Type
3630  createFence( VULKAN_HPP_NAMESPACE::FenceCreateInfo const & createInfo,
3631  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3633 
3634  void resetFences( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences ) const;
3635 
3636  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitForFences( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences,
3637  VULKAN_HPP_NAMESPACE::Bool32 waitAll,
3638  uint64_t timeout ) const;
3639 
3640  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Semaphore>::Type
3641  createSemaphore( VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo const & createInfo,
3642  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3644 
3645  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Event>::Type
3646  createEvent( VULKAN_HPP_NAMESPACE::EventCreateInfo const & createInfo,
3647  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3649 
3650  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::QueryPool>::Type
3651  createQueryPool( VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo const & createInfo,
3652  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3654 
3655  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Buffer>::Type
3656  createBuffer( VULKAN_HPP_NAMESPACE::BufferCreateInfo const & createInfo,
3657  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3659 
3660  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::BufferView>::Type
3661  createBufferView( VULKAN_HPP_NAMESPACE::BufferViewCreateInfo const & createInfo,
3662  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3664 
3665  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Image>::Type
3666  createImage( VULKAN_HPP_NAMESPACE::ImageCreateInfo const & createInfo,
3667  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3669 
3670  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ImageView>::Type
3671  createImageView( VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const & createInfo,
3672  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3674 
3676  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ShaderModule>::Type
3677  createShaderModule( VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo const & createInfo,
3678  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3680 
3682  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache>::Type
3683  createPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo const & createInfo,
3684  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3686 
3688  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>>::Type
3689  createGraphicsPipelines( VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,
3690  VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
3691  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const;
3692 
3693  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>::Type
3694  createGraphicsPipeline( VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,
3695  VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo const & createInfo,
3696  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3698 
3700  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>>::Type
3701  createComputePipelines( VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,
3702  VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
3703  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const;
3704 
3705  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>::Type
3706  createComputePipeline( VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,
3707  VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo const & createInfo,
3708  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3710 
3712  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineLayout>::Type
3713  createPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo const & createInfo,
3714  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3716 
3717  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Sampler>::Type
3718  createSampler( VULKAN_HPP_NAMESPACE::SamplerCreateInfo const & createInfo,
3719  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3721 
3723  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSetLayout>::Type
3724  createDescriptorSetLayout( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo const & createInfo,
3725  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3727 
3729  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorPool>::Type
3730  createDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo const & createInfo,
3731  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3733 
3735  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSet>>::Type
3736  allocateDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo const & allocateInfo ) const;
3737 
3738  void updateDescriptorSets( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites,
3739  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CopyDescriptorSet> const & descriptorCopies ) const
3741 
3742  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Framebuffer>::Type
3743  createFramebuffer( VULKAN_HPP_NAMESPACE::FramebufferCreateInfo const & createInfo,
3744  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3746 
3747  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::RenderPass>::Type
3748  createRenderPass( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo const & createInfo,
3749  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3751 
3752  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CommandPool>::Type
3753  createCommandPool( VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo const & createInfo,
3754  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3756 
3758  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CommandBuffer>>::Type
3759  allocateCommandBuffers( VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo const & allocateInfo ) const;
3760 
3761  //=== VK_VERSION_1_1 ===
3762 
3763  void bindBufferMemory2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos ) const;
3764 
3765  void bindImageMemory2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos ) const;
3766 
3767  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags
3768  getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex ) const VULKAN_HPP_NOEXCEPT;
3769 
3770  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
3771  getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT;
3772 
3773  template <typename X, typename Y, typename... Z>
3774  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
3775  getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT;
3776 
3777  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
3778  getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT;
3779 
3780  template <typename X, typename Y, typename... Z>
3781  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
3782  getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT;
3783 
3784  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>
3785  getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info ) const;
3786 
3787  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Queue>::Type
3788  getQueue2( VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 const & queueInfo ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT;
3789 
3791  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion>::Type
3792  createSamplerYcbcrConversion( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & createInfo,
3793  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3795 
3797  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate>::Type
3798  createDescriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & createInfo,
3799  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3801 
3802  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport
3803  getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT;
3804 
3805  template <typename X, typename Y, typename... Z>
3806  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
3807  getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT;
3808 
3809  //=== VK_VERSION_1_2 ===
3810 
3811  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::RenderPass>::Type
3812  createRenderPass2( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & createInfo,
3813  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3815 
3816  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo, uint64_t timeout ) const;
3817 
3818  void signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo ) const;
3819 
3820  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceAddress
3821  getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT;
3822 
3823  VULKAN_HPP_NODISCARD uint64_t getBufferOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT;
3824 
3825  VULKAN_HPP_NODISCARD uint64_t
3826  getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info ) const VULKAN_HPP_NOEXCEPT;
3827 
3828  //=== VK_VERSION_1_3 ===
3829 
3831  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PrivateDataSlot>::Type
3832  createPrivateDataSlot( VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo const & createInfo,
3833  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3835 
3836  void setPrivateData( VULKAN_HPP_NAMESPACE::ObjectType objectType_,
3837  uint64_t objectHandle,
3838  VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
3839  uint64_t data ) const;
3840 
3841  VULKAN_HPP_NODISCARD uint64_t getPrivateData( VULKAN_HPP_NAMESPACE::ObjectType objectType_,
3842  uint64_t objectHandle,
3843  VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot ) const VULKAN_HPP_NOEXCEPT;
3844 
3845  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
3846  getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT;
3847 
3848  template <typename X, typename Y, typename... Z>
3849  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
3850  getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT;
3851 
3852  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
3853  getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT;
3854 
3855  template <typename X, typename Y, typename... Z>
3856  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
3857  getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT;
3858 
3859  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>
3860  getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const;
3861 
3862  //=== VK_KHR_swapchain ===
3863 
3865  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR>::Type
3866  createSwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & createInfo,
3867  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3869 
3870  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR getGroupPresentCapabilitiesKHR() const;
3871 
3873  getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const;
3874 
3875  VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, uint32_t>
3876  acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR & acquireInfo ) const;
3877 
3878  //=== VK_KHR_display_swapchain ===
3879 
3881  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR>>::Type
3882  createSharedSwapchainsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
3883  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const;
3884 
3886  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR>::Type
3887  createSharedSwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & createInfo,
3888  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3890 
3891  //=== VK_EXT_debug_marker ===
3892 
3893  void debugMarkerSetObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT & tagInfo ) const;
3894 
3895  void debugMarkerSetObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT & nameInfo ) const;
3896 
3897  //=== VK_KHR_video_queue ===
3898 
3900  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::VideoSessionKHR>::Type
3901  createVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const & createInfo,
3902  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3904 
3906  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::VideoSessionParametersKHR>::Type
3907  createVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR const & createInfo,
3908  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3910 
3911  //=== VK_NVX_binary_import ===
3912 
3913  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CuModuleNVX>::Type
3914  createCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX const & createInfo,
3915  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3917 
3919  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CuFunctionNVX>::Type
3920  createCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX const & createInfo,
3921  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3923 
3924  //=== VK_NVX_image_view_handle ===
3925 
3926  VULKAN_HPP_NODISCARD uint32_t getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX & info ) const VULKAN_HPP_NOEXCEPT;
3927 
3928  //=== VK_KHR_device_group ===
3929 
3930  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags
3931  getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex ) const VULKAN_HPP_NOEXCEPT;
3932 
3933 # if defined( VK_USE_PLATFORM_WIN32_KHR )
3934  //=== VK_KHR_external_memory_win32 ===
3935 
3936  VULKAN_HPP_NODISCARD HANDLE getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR & getWin32HandleInfo ) const;
3937 
3938  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR
3939  getMemoryWin32HandlePropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle ) const;
3940 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
3941 
3942  //=== VK_KHR_external_memory_fd ===
3943 
3944  VULKAN_HPP_NODISCARD int getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR & getFdInfo ) const;
3945 
3946  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR
3947  getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, int fd ) const;
3948 
3949 # if defined( VK_USE_PLATFORM_WIN32_KHR )
3950  //=== VK_KHR_external_semaphore_win32 ===
3951 
3952  void importSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo ) const;
3953 
3954  VULKAN_HPP_NODISCARD HANDLE getSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo ) const;
3955 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
3956 
3957  //=== VK_KHR_external_semaphore_fd ===
3958 
3959  void importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo ) const;
3960 
3961  VULKAN_HPP_NODISCARD int getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR & getFdInfo ) const;
3962 
3963  //=== VK_KHR_descriptor_update_template ===
3964 
3966  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate>::Type
3967  createDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & createInfo,
3968  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3970 
3971  void destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
3972  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
3974 
3975  //=== VK_EXT_display_control ===
3976 
3977  void displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT & displayPowerInfo ) const;
3978 
3979  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Fence>::Type
3980  registerEventEXT( VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT const & deviceEventInfo,
3981  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3983 
3984  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Fence>::Type
3985  registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const & display,
3986  VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT const & displayEventInfo,
3987  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
3989 
3990  //=== VK_EXT_hdr_metadata ===
3991 
3992  void setHdrMetadataEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const & swapchains,
3993  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> const & metadata ) const;
3994 
3995  //=== VK_KHR_create_renderpass2 ===
3996 
3997  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::RenderPass>::Type
3998  createRenderPass2KHR( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & createInfo,
3999  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
4001 
4002 # if defined( VK_USE_PLATFORM_WIN32_KHR )
4003  //=== VK_KHR_external_fence_win32 ===
4004 
4005  void importFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo ) const;
4006 
4007  VULKAN_HPP_NODISCARD HANDLE getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR & getWin32HandleInfo ) const;
4008 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
4009 
4010  //=== VK_KHR_external_fence_fd ===
4011 
4012  void importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR & importFenceFdInfo ) const;
4013 
4014  VULKAN_HPP_NODISCARD int getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR & getFdInfo ) const;
4015 
4016  //=== VK_KHR_performance_query ===
4017 
4018  void acquireProfilingLockKHR( const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR & info ) const;
4019 
4020  void releaseProfilingLockKHR() const VULKAN_HPP_NOEXCEPT;
4021 
4022  //=== VK_EXT_debug_utils ===
4023 
4024  void setDebugUtilsObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT & nameInfo ) const;
4025 
4026  void setDebugUtilsObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT & tagInfo ) const;
4027 
4028 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
4029  //=== VK_ANDROID_external_memory_android_hardware_buffer ===
4030 
4031  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID
4032  getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer ) const;
4033 
4034  template <typename X, typename Y, typename... Z>
4035  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
4036  getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer ) const;
4037 
4038  VULKAN_HPP_NODISCARD struct AHardwareBuffer *
4039  getMemoryAndroidHardwareBufferANDROID( const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID & info ) const;
4040 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
4041 
4042 # if defined( VK_ENABLE_BETA_EXTENSIONS )
4043  //=== VK_AMDX_shader_enqueue ===
4044 
4046  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>>::Type
4047  createExecutionGraphPipelinesAMDX(
4048  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,
4049  VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,
4050  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const;
4051 
4052  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>::Type
4053  createExecutionGraphPipelineAMDX(
4054  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,
4055  VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX const & createInfo,
4056  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT;
4057 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
4058 
4059  //=== VK_KHR_get_memory_requirements2 ===
4060 
4061  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
4062  getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT;
4063 
4064  template <typename X, typename Y, typename... Z>
4065  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
4066  getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT;
4067 
4068  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
4069  getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT;
4070 
4071  template <typename X, typename Y, typename... Z>
4072  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
4073  getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT;
4074 
4075  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>
4076  getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info ) const;
4077 
4078  //=== VK_KHR_acceleration_structure ===
4079 
4081  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureKHR>::Type
4082  createAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR const & createInfo,
4083  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
4085 
4086  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result buildAccelerationStructuresKHR(
4087  VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
4088  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,
4089  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos ) const;
4090 
4091  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result
4092  copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
4093  const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info ) const;
4094 
4095  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result
4096  copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
4097  const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info ) const;
4098 
4099  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result
4100  copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
4101  const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info ) const;
4102 
4103  template <typename DataType>
4104  VULKAN_HPP_NODISCARD std::vector<DataType> writeAccelerationStructuresPropertiesKHR(
4105  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
4106  VULKAN_HPP_NAMESPACE::QueryType queryType,
4107  size_t dataSize,
4108  size_t stride ) const;
4109 
4110  template <typename DataType>
4111  VULKAN_HPP_NODISCARD DataType writeAccelerationStructuresPropertyKHR(
4112  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
4113  VULKAN_HPP_NAMESPACE::QueryType queryType,
4114  size_t stride ) const;
4115 
4116  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceAddress
4117  getAccelerationStructureAddressKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR & info ) const VULKAN_HPP_NOEXCEPT;
4118 
4120  getAccelerationStructureCompatibilityKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR & versionInfo ) const VULKAN_HPP_NOEXCEPT;
4121 
4122  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR getAccelerationStructureBuildSizesKHR(
4123  VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType,
4124  const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR & buildInfo,
4125  VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & maxPrimitiveCounts VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const;
4126 
4127  //=== VK_KHR_ray_tracing_pipeline ===
4128 
4130  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>>::Type
4131  createRayTracingPipelinesKHR(
4132  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR> const & deferredOperation,
4133  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,
4134  VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
4135  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const;
4136 
4137  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>::Type
4138  createRayTracingPipelineKHR(
4139  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR> const & deferredOperation,
4140  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,
4141  VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR const & createInfo,
4142  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT;
4143 
4144  //=== VK_KHR_sampler_ycbcr_conversion ===
4145 
4147  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion>::Type
4148  createSamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & createInfo,
4149  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
4151 
4152  void destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
4153  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
4155 
4156  //=== VK_KHR_bind_memory2 ===
4157 
4158  void bindBufferMemory2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos ) const;
4159 
4160  void bindImageMemory2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos ) const;
4161 
4162  //=== VK_EXT_validation_cache ===
4163 
4165  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ValidationCacheEXT>::Type
4166  createValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT const & createInfo,
4167  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
4169 
4170  //=== VK_NV_ray_tracing ===
4171 
4173  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureNV>::Type
4174  createAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV const & createInfo,
4175  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
4177 
4178  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR getAccelerationStructureMemoryRequirementsNV(
4179  const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT;
4180 
4181  template <typename X, typename Y, typename... Z>
4182  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getAccelerationStructureMemoryRequirementsNV(
4183  const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT;
4184 
4185  void bindAccelerationStructureMemoryNV(
4186  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> const & bindInfos ) const;
4187 
4189  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>>::Type
4190  createRayTracingPipelinesNV( VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,
4191  VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
4192  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const;
4193 
4194  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>::Type
4195  createRayTracingPipelineNV( VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,
4196  VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV const & createInfo,
4197  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
4199 
4200  //=== VK_KHR_maintenance3 ===
4201 
4202  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport
4203  getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT;
4204 
4205  template <typename X, typename Y, typename... Z>
4206  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
4207  getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT;
4208 
4209  //=== VK_EXT_external_memory_host ===
4210 
4212  getMemoryHostPointerPropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, const void * pHostPointer ) const;
4213 
4214  //=== VK_EXT_calibrated_timestamps ===
4215 
4216  VULKAN_HPP_NODISCARD std::pair<std::vector<uint64_t>, uint64_t>
4217  getCalibratedTimestampsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos ) const;
4218 
4219  VULKAN_HPP_NODISCARD std::pair<uint64_t, uint64_t>
4220  getCalibratedTimestampEXT( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR & timestampInfo ) const;
4221 
4222  //=== VK_KHR_timeline_semaphore ===
4223 
4224  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo, uint64_t timeout ) const;
4225 
4226  void signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo ) const;
4227 
4228  //=== VK_INTEL_performance_query ===
4229 
4230  void initializePerformanceApiINTEL( const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL & initializeInfo ) const;
4231 
4232  void uninitializePerformanceApiINTEL() const VULKAN_HPP_NOEXCEPT;
4233 
4235  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PerformanceConfigurationINTEL>::Type
4236  acquirePerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const & acquireInfo ) const
4238 
4239  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::PerformanceValueINTEL
4240  getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter ) const;
4241 
4242  //=== VK_EXT_buffer_device_address ===
4243 
4244  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceAddress
4245  getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT;
4246 
4247 # if defined( VK_USE_PLATFORM_WIN32_KHR )
4248  //=== VK_EXT_full_screen_exclusive ===
4249 
4251  getGroupSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const;
4252 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
4253 
4254  //=== VK_KHR_buffer_device_address ===
4255 
4257  getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT;
4258 
4259  VULKAN_HPP_NODISCARD uint64_t getBufferOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT;
4260 
4261  VULKAN_HPP_NODISCARD uint64_t
4262  getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info ) const VULKAN_HPP_NOEXCEPT;
4263 
4264  //=== VK_KHR_deferred_host_operations ===
4265 
4267  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR>::Type
4268  createDeferredOperationKHR( VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
4270 
4271  //=== VK_KHR_pipeline_executable_properties ===
4272 
4273  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>
4274  getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR & pipelineInfo ) const;
4275 
4276  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>
4277  getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo ) const;
4278 
4280  getPipelineExecutableInternalRepresentationsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo ) const;
4281 
4282  //=== VK_EXT_host_image_copy ===
4283 
4284  void copyMemoryToImageEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfoEXT & copyMemoryToImageInfo ) const;
4285 
4286  void copyImageToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfoEXT & copyImageToMemoryInfo ) const;
4287 
4288  void copyImageToImageEXT( const VULKAN_HPP_NAMESPACE::CopyImageToImageInfoEXT & copyImageToImageInfo ) const;
4289 
4290  void transitionImageLayoutEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfoEXT> const & transitions ) const;
4291 
4292  //=== VK_KHR_map_memory2 ===
4293 
4294  VULKAN_HPP_NODISCARD void * mapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR & memoryMapInfo ) const;
4295 
4296  void unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR & memoryUnmapInfo ) const VULKAN_HPP_NOEXCEPT;
4297 
4298  //=== VK_EXT_swapchain_maintenance1 ===
4299 
4300  void releaseSwapchainImagesEXT( const VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT & releaseInfo ) const;
4301 
4302  //=== VK_NV_device_generated_commands ===
4303 
4304  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
4305  getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT;
4306 
4307  template <typename X, typename Y, typename... Z>
4308  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
4309  getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT;
4310 
4312  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::IndirectCommandsLayoutNV>::Type
4313  createIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV const & createInfo,
4314  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
4316 
4317  //=== VK_EXT_private_data ===
4318 
4320  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PrivateDataSlot>::Type
4321  createPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo const & createInfo,
4322  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
4324 
4325  void destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
4326  Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator
4328 
4329  void setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType_,
4330  uint64_t objectHandle,
4331  VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
4332  uint64_t data ) const;
4333 
4334  VULKAN_HPP_NODISCARD uint64_t getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType_,
4335  uint64_t objectHandle,
4336  VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot ) const VULKAN_HPP_NOEXCEPT;
4337 
4338  //=== VK_KHR_video_encode_queue ===
4339 
4340  VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR, std::vector<uint8_t>>
4341  getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo ) const;
4342 
4343  template <typename X, typename Y, typename... Z>
4344  VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>, std::vector<uint8_t>>
4345  getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo ) const;
4346 
4347 # if defined( VK_ENABLE_BETA_EXTENSIONS )
4348  //=== VK_NV_cuda_kernel_launch ===
4349 
4351  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CudaModuleNV>::Type
4352  createCudaModuleNV( VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV const & createInfo,
4353  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
4355 
4357  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CudaFunctionNV>::Type
4358  createCudaFunctionNV( VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV const & createInfo,
4359  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
4361 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
4362 
4363 # if defined( VK_USE_PLATFORM_METAL_EXT )
4364  //=== VK_EXT_metal_objects ===
4365 
4366  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT exportMetalObjectsEXT() const VULKAN_HPP_NOEXCEPT;
4367 
4368  template <typename X, typename Y, typename... Z>
4369  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> exportMetalObjectsEXT() const VULKAN_HPP_NOEXCEPT;
4370 # endif /*VK_USE_PLATFORM_METAL_EXT*/
4371 
4372  //=== VK_EXT_descriptor_buffer ===
4373 
4374  void getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT & descriptorInfo, size_t dataSize, void * pDescriptor ) const VULKAN_HPP_NOEXCEPT;
4375 
4376  template <typename DescriptorType>
4377  VULKAN_HPP_NODISCARD DescriptorType getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT & descriptorInfo ) const VULKAN_HPP_NOEXCEPT;
4378 
4379  template <typename DataType>
4380  VULKAN_HPP_NODISCARD DataType getBufferOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT & info ) const;
4381 
4382  template <typename DataType>
4383  VULKAN_HPP_NODISCARD DataType getImageOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT & info ) const;
4384 
4385  template <typename DataType>
4386  VULKAN_HPP_NODISCARD DataType
4387  getImageViewOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT & info ) const;
4388 
4389  template <typename DataType>
4390  VULKAN_HPP_NODISCARD DataType getSamplerOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT & info ) const;
4391 
4392  template <typename DataType>
4393  VULKAN_HPP_NODISCARD DataType
4394  getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT & info ) const;
4395 
4396  //=== VK_EXT_device_fault ===
4397 
4399  std::pair<VULKAN_HPP_NAMESPACE::Result, std::pair<VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT, VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT>>
4400  getFaultInfoEXT() const;
4401 
4402 # if defined( VK_USE_PLATFORM_FUCHSIA )
4403  //=== VK_FUCHSIA_external_memory ===
4404 
4405  VULKAN_HPP_NODISCARD zx_handle_t getMemoryZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo ) const;
4406 
4407  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA
4408  getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle ) const;
4409 # endif /*VK_USE_PLATFORM_FUCHSIA*/
4410 
4411 # if defined( VK_USE_PLATFORM_FUCHSIA )
4412  //=== VK_FUCHSIA_external_semaphore ===
4413 
4414  void importSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo ) const;
4415 
4416  VULKAN_HPP_NODISCARD zx_handle_t
4417  getSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo ) const;
4418 # endif /*VK_USE_PLATFORM_FUCHSIA*/
4419 
4420 # if defined( VK_USE_PLATFORM_FUCHSIA )
4421  //=== VK_FUCHSIA_buffer_collection ===
4422 
4424  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::BufferCollectionFUCHSIA>::Type
4425  createBufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA const & createInfo,
4426  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
4428 # endif /*VK_USE_PLATFORM_FUCHSIA*/
4429 
4430  //=== VK_NV_external_memory_rdma ===
4431 
4433  getMemoryRemoteAddressNV( const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV & memoryGetRemoteAddressInfo ) const;
4434 
4435  //=== VK_EXT_pipeline_properties ===
4436 
4437  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::BaseOutStructure getPipelinePropertiesEXT( const VULKAN_HPP_NAMESPACE::PipelineInfoEXT & pipelineInfo ) const;
4438 
4439  //=== VK_EXT_opacity_micromap ===
4440 
4441  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::MicromapEXT>::Type
4442  createMicromapEXT( VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT const & createInfo,
4443  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
4445 
4446  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result
4447  buildMicromapsEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
4448  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT> const & infos ) const;
4449 
4450  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
4451  const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT & info ) const;
4452 
4453  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyMicromapToMemoryEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
4454  const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT & info ) const;
4455 
4456  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result copyMemoryToMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
4457  const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT & info ) const;
4458 
4459  template <typename DataType>
4460  VULKAN_HPP_NODISCARD std::vector<DataType>
4461  writeMicromapsPropertiesEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps,
4462  VULKAN_HPP_NAMESPACE::QueryType queryType,
4463  size_t dataSize,
4464  size_t stride ) const;
4465 
4466  template <typename DataType>
4467  VULKAN_HPP_NODISCARD DataType writeMicromapsPropertyEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps,
4468  VULKAN_HPP_NAMESPACE::QueryType queryType,
4469  size_t stride ) const;
4470 
4472  getMicromapCompatibilityEXT( const VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT & versionInfo ) const VULKAN_HPP_NOEXCEPT;
4473 
4474  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT
4475  getMicromapBuildSizesEXT( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType,
4476  const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT & buildInfo ) const VULKAN_HPP_NOEXCEPT;
4477 
4478  //=== VK_KHR_maintenance4 ===
4479 
4480  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
4481  getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT;
4482 
4483  template <typename X, typename Y, typename... Z>
4484  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
4485  getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT;
4486 
4487  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
4488  getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT;
4489 
4490  template <typename X, typename Y, typename... Z>
4491  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
4492  getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT;
4493 
4494  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>
4495  getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const;
4496 
4497  //=== VK_VALVE_descriptor_set_host_mapping ===
4498 
4499  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE getDescriptorSetLayoutHostMappingInfoVALVE(
4500  const VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE & bindingReference ) const VULKAN_HPP_NOEXCEPT;
4501 
4502  //=== VK_NV_device_generated_commands_compute ===
4503 
4504  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements2
4505  getPipelineIndirectMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT;
4506 
4507  template <typename X, typename Y, typename... Z>
4508  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
4509  getPipelineIndirectMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT;
4510 
4511  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceAddress
4512  getPipelineIndirectAddressNV( const VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV & info ) const VULKAN_HPP_NOEXCEPT;
4513 
4514  //=== VK_EXT_shader_module_identifier ===
4515 
4516  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT
4517  getShaderModuleCreateInfoIdentifierEXT( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT;
4518 
4519  //=== VK_NV_optical_flow ===
4520 
4522  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::OpticalFlowSessionNV>::Type
4523  createOpticalFlowSessionNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV const & createInfo,
4524  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
4526 
4527  //=== VK_KHR_maintenance5 ===
4528 
4529  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Extent2D
4530  getRenderingAreaGranularityKHR( const VULKAN_HPP_NAMESPACE::RenderingAreaInfoKHR & renderingAreaInfo ) const VULKAN_HPP_NOEXCEPT;
4531 
4532  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR
4533  getImageSubresourceLayoutKHR( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfoKHR & info ) const VULKAN_HPP_NOEXCEPT;
4534 
4535  template <typename X, typename Y, typename... Z>
4536  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
4537  getImageSubresourceLayoutKHR( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfoKHR & info ) const VULKAN_HPP_NOEXCEPT;
4538 
4539  //=== VK_EXT_shader_object ===
4540 
4542  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ShaderEXT>>::Type
4543  createShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos,
4544  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const;
4545 
4546  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ShaderEXT>::Type
4547  createShaderEXT( VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT const & createInfo,
4548  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const
4550 
4551  //=== VK_QCOM_tile_properties ===
4552 
4553  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::TilePropertiesQCOM
4554  getDynamicRenderingTilePropertiesQCOM( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo ) const VULKAN_HPP_NOEXCEPT;
4555 
4556 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
4557  //=== VK_QNX_external_memory_screen_buffer ===
4558 
4559  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer ) const;
4560 
4561  template <typename X, typename Y, typename... Z>
4562  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer ) const;
4563 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/
4564 
4565  //=== VK_KHR_calibrated_timestamps ===
4566 
4567  VULKAN_HPP_NODISCARD std::pair<std::vector<uint64_t>, uint64_t>
4568  getCalibratedTimestampsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos ) const;
4569 
4570  VULKAN_HPP_NODISCARD std::pair<uint64_t, uint64_t>
4571  getCalibratedTimestampKHR( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR & timestampInfo ) const;
4572 
4573  private:
4574  VULKAN_HPP_NAMESPACE::Device m_device = {};
4575  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
4576  std::unique_ptr<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher> m_dispatcher;
4577  };
4578 
4580  {
4581  public:
4584 
4585  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureKHR;
4587  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureKHR;
4588 
4589  public:
4590 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
4591  AccelerationStructureKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
4592  VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR const & createInfo,
4593  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
4594  {
4595  *this = device.createAccelerationStructureKHR( createInfo, allocator );
4596  }
4597 # endif
4598 
4599  AccelerationStructureKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
4600  VkAccelerationStructureKHR accelerationStructure,
4601  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
4602  : m_device( device )
4603  , m_accelerationStructure( accelerationStructure )
4604  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
4605  , m_dispatcher( device.getDispatcher() )
4606  {
4607  }
4608 
4609  AccelerationStructureKHR( std::nullptr_t ) {}
4610 
4612  {
4613  clear();
4614  }
4615 
4618 
4620  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
4621  , m_accelerationStructure( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_accelerationStructure, {} ) )
4622  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
4623  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
4624  {
4625  }
4626 
4628 
4630  {
4631  if ( this != &rhs )
4632  {
4633  std::swap( m_device, rhs.m_device );
4634  std::swap( m_accelerationStructure, rhs.m_accelerationStructure );
4635  std::swap( m_allocator, rhs.m_allocator );
4636  std::swap( m_dispatcher, rhs.m_dispatcher );
4637  }
4638  return *this;
4639  }
4640 
4641  VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const & operator*() const VULKAN_HPP_NOEXCEPT
4642  {
4643  return m_accelerationStructure;
4644  }
4645 
4646  operator VULKAN_HPP_NAMESPACE::AccelerationStructureKHR() const VULKAN_HPP_NOEXCEPT
4647  {
4648  return m_accelerationStructure;
4649  }
4650 
4652  {
4653  if ( m_accelerationStructure )
4654  {
4655  getDispatcher()->vkDestroyAccelerationStructureKHR( static_cast<VkDevice>( m_device ),
4656  static_cast<VkAccelerationStructureKHR>( m_accelerationStructure ),
4657  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
4658  }
4659  m_device = nullptr;
4660  m_accelerationStructure = nullptr;
4661  m_allocator = nullptr;
4662  m_dispatcher = nullptr;
4663  }
4664 
4665  VULKAN_HPP_NAMESPACE::AccelerationStructureKHR release()
4666  {
4667  m_device = nullptr;
4668  m_allocator = nullptr;
4669  m_dispatcher = nullptr;
4670  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_accelerationStructure, nullptr );
4671  }
4672 
4673  VULKAN_HPP_NAMESPACE::Device getDevice() const
4674  {
4675  return m_device;
4676  }
4677 
4678  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
4679  {
4680  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
4681  return m_dispatcher;
4682  }
4683 
4684  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureKHR & rhs ) VULKAN_HPP_NOEXCEPT
4685  {
4686  std::swap( m_device, rhs.m_device );
4687  std::swap( m_accelerationStructure, rhs.m_accelerationStructure );
4688  std::swap( m_allocator, rhs.m_allocator );
4689  std::swap( m_dispatcher, rhs.m_dispatcher );
4690  }
4691 
4692  private:
4693  VULKAN_HPP_NAMESPACE::Device m_device = {};
4694  VULKAN_HPP_NAMESPACE::AccelerationStructureKHR m_accelerationStructure = {};
4695  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
4696  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
4697  };
4698 
4700  {
4701  public:
4704 
4705  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eAccelerationStructureNV;
4707  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eAccelerationStructureNV;
4708 
4709  public:
4710 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
4711  AccelerationStructureNV( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
4712  VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV const & createInfo,
4713  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
4714  {
4715  *this = device.createAccelerationStructureNV( createInfo, allocator );
4716  }
4717 # endif
4718 
4719  AccelerationStructureNV( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
4720  VkAccelerationStructureNV accelerationStructure,
4721  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
4722  : m_device( device )
4723  , m_accelerationStructure( accelerationStructure )
4724  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
4725  , m_dispatcher( device.getDispatcher() )
4726  {
4727  }
4728 
4729  AccelerationStructureNV( std::nullptr_t ) {}
4730 
4732  {
4733  clear();
4734  }
4735 
4738 
4740  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
4741  , m_accelerationStructure( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_accelerationStructure, {} ) )
4742  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
4743  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
4744  {
4745  }
4746 
4748 
4750  {
4751  if ( this != &rhs )
4752  {
4753  std::swap( m_device, rhs.m_device );
4754  std::swap( m_accelerationStructure, rhs.m_accelerationStructure );
4755  std::swap( m_allocator, rhs.m_allocator );
4756  std::swap( m_dispatcher, rhs.m_dispatcher );
4757  }
4758  return *this;
4759  }
4760 
4761  VULKAN_HPP_NAMESPACE::AccelerationStructureNV const & operator*() const VULKAN_HPP_NOEXCEPT
4762  {
4763  return m_accelerationStructure;
4764  }
4765 
4766  operator VULKAN_HPP_NAMESPACE::AccelerationStructureNV() const VULKAN_HPP_NOEXCEPT
4767  {
4768  return m_accelerationStructure;
4769  }
4770 
4772  {
4773  if ( m_accelerationStructure )
4774  {
4775  getDispatcher()->vkDestroyAccelerationStructureNV( static_cast<VkDevice>( m_device ),
4776  static_cast<VkAccelerationStructureNV>( m_accelerationStructure ),
4777  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
4778  }
4779  m_device = nullptr;
4780  m_accelerationStructure = nullptr;
4781  m_allocator = nullptr;
4782  m_dispatcher = nullptr;
4783  }
4784 
4785  VULKAN_HPP_NAMESPACE::AccelerationStructureNV release()
4786  {
4787  m_device = nullptr;
4788  m_allocator = nullptr;
4789  m_dispatcher = nullptr;
4790  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_accelerationStructure, nullptr );
4791  }
4792 
4793  VULKAN_HPP_NAMESPACE::Device getDevice() const
4794  {
4795  return m_device;
4796  }
4797 
4798  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
4799  {
4800  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
4801  return m_dispatcher;
4802  }
4803 
4804  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureNV & rhs ) VULKAN_HPP_NOEXCEPT
4805  {
4806  std::swap( m_device, rhs.m_device );
4807  std::swap( m_accelerationStructure, rhs.m_accelerationStructure );
4808  std::swap( m_allocator, rhs.m_allocator );
4809  std::swap( m_dispatcher, rhs.m_dispatcher );
4810  }
4811 
4812  //=== VK_NV_ray_tracing ===
4813 
4814  template <typename DataType>
4815  VULKAN_HPP_NODISCARD std::vector<DataType> getHandle( size_t dataSize ) const;
4816 
4817  template <typename DataType>
4819 
4820  private:
4821  VULKAN_HPP_NAMESPACE::Device m_device = {};
4822  VULKAN_HPP_NAMESPACE::AccelerationStructureNV m_accelerationStructure = {};
4823  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
4824  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
4825  };
4826 
4827  class Buffer
4828  {
4829  public:
4830  using CType = VkBuffer;
4832 
4833  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBuffer;
4835  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBuffer;
4836 
4837  public:
4838 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
4839  Buffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
4840  VULKAN_HPP_NAMESPACE::BufferCreateInfo const & createInfo,
4841  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
4842  {
4843  *this = device.createBuffer( createInfo, allocator );
4844  }
4845 # endif
4846 
4847  Buffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
4848  VkBuffer buffer,
4849  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
4850  : m_device( device )
4851  , m_buffer( buffer )
4852  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
4853  , m_dispatcher( device.getDispatcher() )
4854  {
4855  }
4856 
4857  Buffer( std::nullptr_t ) {}
4858 
4860  {
4861  clear();
4862  }
4863 
4864  Buffer() = delete;
4865  Buffer( Buffer const & ) = delete;
4866 
4868  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
4869  , m_buffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_buffer, {} ) )
4870  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
4871  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
4872  {
4873  }
4874 
4875  Buffer & operator=( Buffer const & ) = delete;
4876 
4878  {
4879  if ( this != &rhs )
4880  {
4881  std::swap( m_device, rhs.m_device );
4882  std::swap( m_buffer, rhs.m_buffer );
4883  std::swap( m_allocator, rhs.m_allocator );
4884  std::swap( m_dispatcher, rhs.m_dispatcher );
4885  }
4886  return *this;
4887  }
4888 
4889  VULKAN_HPP_NAMESPACE::Buffer const & operator*() const VULKAN_HPP_NOEXCEPT
4890  {
4891  return m_buffer;
4892  }
4893 
4894  operator VULKAN_HPP_NAMESPACE::Buffer() const VULKAN_HPP_NOEXCEPT
4895  {
4896  return m_buffer;
4897  }
4898 
4900  {
4901  if ( m_buffer )
4902  {
4903  getDispatcher()->vkDestroyBuffer(
4904  static_cast<VkDevice>( m_device ), static_cast<VkBuffer>( m_buffer ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
4905  }
4906  m_device = nullptr;
4907  m_buffer = nullptr;
4908  m_allocator = nullptr;
4909  m_dispatcher = nullptr;
4910  }
4911 
4912  VULKAN_HPP_NAMESPACE::Buffer release()
4913  {
4914  m_device = nullptr;
4915  m_allocator = nullptr;
4916  m_dispatcher = nullptr;
4918  }
4919 
4920  VULKAN_HPP_NAMESPACE::Device getDevice() const
4921  {
4922  return m_device;
4923  }
4924 
4925  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
4926  {
4927  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
4928  return m_dispatcher;
4929  }
4930 
4931  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Buffer & rhs ) VULKAN_HPP_NOEXCEPT
4932  {
4933  std::swap( m_device, rhs.m_device );
4934  std::swap( m_buffer, rhs.m_buffer );
4935  std::swap( m_allocator, rhs.m_allocator );
4936  std::swap( m_dispatcher, rhs.m_dispatcher );
4937  }
4938 
4939  //=== VK_VERSION_1_0 ===
4940 
4941  void bindMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset ) const;
4942 
4943  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements getMemoryRequirements() const VULKAN_HPP_NOEXCEPT;
4944 
4945  private:
4946  VULKAN_HPP_NAMESPACE::Device m_device = {};
4947  VULKAN_HPP_NAMESPACE::Buffer m_buffer = {};
4948  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
4949  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
4950  };
4951 
4952 # if defined( VK_USE_PLATFORM_FUCHSIA )
4953  class BufferCollectionFUCHSIA
4954  {
4955  public:
4956  using CType = VkBufferCollectionFUCHSIA;
4957  using CppType = vk::BufferCollectionFUCHSIA;
4958 
4959  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBufferCollectionFUCHSIA;
4961  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA;
4962 
4963  public:
4964 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
4965  BufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
4966  VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA const & createInfo,
4967  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
4968  {
4969  *this = device.createBufferCollectionFUCHSIA( createInfo, allocator );
4970  }
4971 # endif
4972 
4973  BufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
4974  VkBufferCollectionFUCHSIA collection,
4975  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
4976  : m_device( device )
4977  , m_collection( collection )
4978  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
4979  , m_dispatcher( device.getDispatcher() )
4980  {
4981  }
4982 
4983  BufferCollectionFUCHSIA( std::nullptr_t ) {}
4984 
4985  ~BufferCollectionFUCHSIA()
4986  {
4987  clear();
4988  }
4989 
4990  BufferCollectionFUCHSIA() = delete;
4991  BufferCollectionFUCHSIA( BufferCollectionFUCHSIA const & ) = delete;
4992 
4993  BufferCollectionFUCHSIA( BufferCollectionFUCHSIA && rhs ) VULKAN_HPP_NOEXCEPT
4994  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
4995  , m_collection( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_collection, {} ) )
4996  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
4997  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
4998  {
4999  }
5000 
5001  BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA const & ) = delete;
5002 
5003  BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA && rhs ) VULKAN_HPP_NOEXCEPT
5004  {
5005  if ( this != &rhs )
5006  {
5007  std::swap( m_device, rhs.m_device );
5008  std::swap( m_collection, rhs.m_collection );
5009  std::swap( m_allocator, rhs.m_allocator );
5010  std::swap( m_dispatcher, rhs.m_dispatcher );
5011  }
5012  return *this;
5013  }
5014 
5015  VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const & operator*() const VULKAN_HPP_NOEXCEPT
5016  {
5017  return m_collection;
5018  }
5019 
5020  operator VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA() const VULKAN_HPP_NOEXCEPT
5021  {
5022  return m_collection;
5023  }
5024 
5025  void clear() VULKAN_HPP_NOEXCEPT
5026  {
5027  if ( m_collection )
5028  {
5029  getDispatcher()->vkDestroyBufferCollectionFUCHSIA( static_cast<VkDevice>( m_device ),
5030  static_cast<VkBufferCollectionFUCHSIA>( m_collection ),
5031  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
5032  }
5033  m_device = nullptr;
5034  m_collection = nullptr;
5035  m_allocator = nullptr;
5036  m_dispatcher = nullptr;
5037  }
5038 
5039  VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA release()
5040  {
5041  m_device = nullptr;
5042  m_allocator = nullptr;
5043  m_dispatcher = nullptr;
5044  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_collection, nullptr );
5045  }
5046 
5047  VULKAN_HPP_NAMESPACE::Device getDevice() const
5048  {
5049  return m_device;
5050  }
5051 
5052  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
5053  {
5054  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
5055  return m_dispatcher;
5056  }
5057 
5058  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::BufferCollectionFUCHSIA & rhs ) VULKAN_HPP_NOEXCEPT
5059  {
5060  std::swap( m_device, rhs.m_device );
5061  std::swap( m_collection, rhs.m_collection );
5062  std::swap( m_allocator, rhs.m_allocator );
5063  std::swap( m_dispatcher, rhs.m_dispatcher );
5064  }
5065 
5066  //=== VK_FUCHSIA_buffer_collection ===
5067 
5068  void setImageConstraints( const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA & imageConstraintsInfo ) const;
5069 
5070  void setBufferConstraints( const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA & bufferConstraintsInfo ) const;
5071 
5072  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA getProperties() const;
5073 
5074  private:
5075  VULKAN_HPP_NAMESPACE::Device m_device = {};
5076  VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA m_collection = {};
5077  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
5078  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
5079  };
5080 # endif /*VK_USE_PLATFORM_FUCHSIA*/
5081 
5083  {
5084  public:
5087 
5088  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eBufferView;
5090  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eBufferView;
5091 
5092  public:
5093 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
5094  BufferView( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
5095  VULKAN_HPP_NAMESPACE::BufferViewCreateInfo const & createInfo,
5096  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
5097  {
5098  *this = device.createBufferView( createInfo, allocator );
5099  }
5100 # endif
5101 
5102  BufferView( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
5103  VkBufferView bufferView,
5104  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
5105  : m_device( device )
5106  , m_bufferView( bufferView )
5107  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
5108  , m_dispatcher( device.getDispatcher() )
5109  {
5110  }
5111 
5112  BufferView( std::nullptr_t ) {}
5113 
5115  {
5116  clear();
5117  }
5118 
5119  BufferView() = delete;
5120  BufferView( BufferView const & ) = delete;
5121 
5123  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
5124  , m_bufferView( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_bufferView, {} ) )
5125  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
5126  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
5127  {
5128  }
5129 
5130  BufferView & operator=( BufferView const & ) = delete;
5131 
5133  {
5134  if ( this != &rhs )
5135  {
5136  std::swap( m_device, rhs.m_device );
5137  std::swap( m_bufferView, rhs.m_bufferView );
5138  std::swap( m_allocator, rhs.m_allocator );
5139  std::swap( m_dispatcher, rhs.m_dispatcher );
5140  }
5141  return *this;
5142  }
5143 
5144  VULKAN_HPP_NAMESPACE::BufferView const & operator*() const VULKAN_HPP_NOEXCEPT
5145  {
5146  return m_bufferView;
5147  }
5148 
5149  operator VULKAN_HPP_NAMESPACE::BufferView() const VULKAN_HPP_NOEXCEPT
5150  {
5151  return m_bufferView;
5152  }
5153 
5155  {
5156  if ( m_bufferView )
5157  {
5158  getDispatcher()->vkDestroyBufferView(
5159  static_cast<VkDevice>( m_device ), static_cast<VkBufferView>( m_bufferView ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
5160  }
5161  m_device = nullptr;
5162  m_bufferView = nullptr;
5163  m_allocator = nullptr;
5164  m_dispatcher = nullptr;
5165  }
5166 
5167  VULKAN_HPP_NAMESPACE::BufferView release()
5168  {
5169  m_device = nullptr;
5170  m_allocator = nullptr;
5171  m_dispatcher = nullptr;
5172  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_bufferView, nullptr );
5173  }
5174 
5175  VULKAN_HPP_NAMESPACE::Device getDevice() const
5176  {
5177  return m_device;
5178  }
5179 
5180  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
5181  {
5182  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
5183  return m_dispatcher;
5184  }
5185 
5186  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::BufferView & rhs ) VULKAN_HPP_NOEXCEPT
5187  {
5188  std::swap( m_device, rhs.m_device );
5189  std::swap( m_bufferView, rhs.m_bufferView );
5190  std::swap( m_allocator, rhs.m_allocator );
5191  std::swap( m_dispatcher, rhs.m_dispatcher );
5192  }
5193 
5194  private:
5195  VULKAN_HPP_NAMESPACE::Device m_device = {};
5196  VULKAN_HPP_NAMESPACE::BufferView m_bufferView = {};
5197  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
5198  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
5199  };
5200 
5202  {
5203  public:
5206 
5207  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCommandPool;
5209  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandPool;
5210 
5211  public:
5212 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
5213  CommandPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
5214  VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo const & createInfo,
5215  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
5216  {
5217  *this = device.createCommandPool( createInfo, allocator );
5218  }
5219 # endif
5220 
5221  CommandPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
5222  VkCommandPool commandPool,
5223  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
5224  : m_device( device )
5225  , m_commandPool( commandPool )
5226  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
5227  , m_dispatcher( device.getDispatcher() )
5228  {
5229  }
5230 
5231  CommandPool( std::nullptr_t ) {}
5232 
5234  {
5235  clear();
5236  }
5237 
5238  CommandPool() = delete;
5239  CommandPool( CommandPool const & ) = delete;
5240 
5242  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
5243  , m_commandPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_commandPool, {} ) )
5244  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
5245  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
5246  {
5247  }
5248 
5249  CommandPool & operator=( CommandPool const & ) = delete;
5250 
5252  {
5253  if ( this != &rhs )
5254  {
5255  std::swap( m_device, rhs.m_device );
5256  std::swap( m_commandPool, rhs.m_commandPool );
5257  std::swap( m_allocator, rhs.m_allocator );
5258  std::swap( m_dispatcher, rhs.m_dispatcher );
5259  }
5260  return *this;
5261  }
5262 
5263  VULKAN_HPP_NAMESPACE::CommandPool const & operator*() const VULKAN_HPP_NOEXCEPT
5264  {
5265  return m_commandPool;
5266  }
5267 
5268  operator VULKAN_HPP_NAMESPACE::CommandPool() const VULKAN_HPP_NOEXCEPT
5269  {
5270  return m_commandPool;
5271  }
5272 
5274  {
5275  if ( m_commandPool )
5276  {
5277  getDispatcher()->vkDestroyCommandPool(
5278  static_cast<VkDevice>( m_device ), static_cast<VkCommandPool>( m_commandPool ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
5279  }
5280  m_device = nullptr;
5281  m_commandPool = nullptr;
5282  m_allocator = nullptr;
5283  m_dispatcher = nullptr;
5284  }
5285 
5286  VULKAN_HPP_NAMESPACE::CommandPool release()
5287  {
5288  m_device = nullptr;
5289  m_allocator = nullptr;
5290  m_dispatcher = nullptr;
5291  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_commandPool, nullptr );
5292  }
5293 
5294  VULKAN_HPP_NAMESPACE::Device getDevice() const
5295  {
5296  return m_device;
5297  }
5298 
5299  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
5300  {
5301  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
5302  return m_dispatcher;
5303  }
5304 
5305  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CommandPool & rhs ) VULKAN_HPP_NOEXCEPT
5306  {
5307  std::swap( m_device, rhs.m_device );
5308  std::swap( m_commandPool, rhs.m_commandPool );
5309  std::swap( m_allocator, rhs.m_allocator );
5310  std::swap( m_dispatcher, rhs.m_dispatcher );
5311  }
5312 
5313  //=== VK_VERSION_1_0 ===
5314 
5316 
5317  //=== VK_VERSION_1_1 ===
5318 
5320 
5321  //=== VK_KHR_maintenance1 ===
5322 
5324 
5325  private:
5326  VULKAN_HPP_NAMESPACE::Device m_device = {};
5327  VULKAN_HPP_NAMESPACE::CommandPool m_commandPool = {};
5328  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
5329  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
5330  };
5331 
5333  {
5334  public:
5337 
5338  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCommandBuffer;
5340  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCommandBuffer;
5341 
5342  public:
5343  CommandBuffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkCommandBuffer commandBuffer, VkCommandPool commandPool )
5344  : m_device( device ), m_commandPool( commandPool ), m_commandBuffer( commandBuffer ), m_dispatcher( device.getDispatcher() )
5345  {
5346  }
5347 
5348  CommandBuffer( std::nullptr_t ) {}
5349 
5351  {
5352  clear();
5353  }
5354 
5355  CommandBuffer() = delete;
5356  CommandBuffer( CommandBuffer const & ) = delete;
5357 
5359  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
5360  , m_commandPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_commandPool, {} ) )
5361  , m_commandBuffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_commandBuffer, {} ) )
5362  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
5363  {
5364  }
5365 
5366  CommandBuffer & operator=( CommandBuffer const & ) = delete;
5367 
5369  {
5370  if ( this != &rhs )
5371  {
5372  std::swap( m_device, rhs.m_device );
5373  std::swap( m_commandPool, rhs.m_commandPool );
5374  std::swap( m_commandBuffer, rhs.m_commandBuffer );
5375  std::swap( m_dispatcher, rhs.m_dispatcher );
5376  }
5377  return *this;
5378  }
5379 
5380  VULKAN_HPP_NAMESPACE::CommandBuffer const & operator*() const VULKAN_HPP_NOEXCEPT
5381  {
5382  return m_commandBuffer;
5383  }
5384 
5385  operator VULKAN_HPP_NAMESPACE::CommandBuffer() const VULKAN_HPP_NOEXCEPT
5386  {
5387  return m_commandBuffer;
5388  }
5389 
5391  {
5392  if ( m_commandBuffer )
5393  {
5394  getDispatcher()->vkFreeCommandBuffers(
5395  static_cast<VkDevice>( m_device ), static_cast<VkCommandPool>( m_commandPool ), 1, reinterpret_cast<VkCommandBuffer const *>( &m_commandBuffer ) );
5396  }
5397  m_device = nullptr;
5398  m_commandPool = nullptr;
5399  m_commandBuffer = nullptr;
5400  m_dispatcher = nullptr;
5401  }
5402 
5403  VULKAN_HPP_NAMESPACE::CommandBuffer release()
5404  {
5405  m_device = nullptr;
5406  m_commandPool = nullptr;
5407  m_dispatcher = nullptr;
5408  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_commandBuffer, nullptr );
5409  }
5410 
5411  VULKAN_HPP_NAMESPACE::Device getDevice() const
5412  {
5413  return m_device;
5414  }
5415 
5416  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
5417  {
5418  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
5419  return m_dispatcher;
5420  }
5421 
5422  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CommandBuffer & rhs ) VULKAN_HPP_NOEXCEPT
5423  {
5424  std::swap( m_device, rhs.m_device );
5425  std::swap( m_commandPool, rhs.m_commandPool );
5426  std::swap( m_commandBuffer, rhs.m_commandBuffer );
5427  std::swap( m_dispatcher, rhs.m_dispatcher );
5428  }
5429 
5430  //=== VK_VERSION_1_0 ===
5431 
5432  void begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo & beginInfo ) const;
5433 
5434  void end() const;
5435 
5437 
5438  void bindPipeline( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::Pipeline pipeline ) const VULKAN_HPP_NOEXCEPT;
5439 
5440  void setViewport( uint32_t firstViewport,
5441  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports ) const VULKAN_HPP_NOEXCEPT;
5442 
5443  void setScissor( uint32_t firstScissor, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors ) const VULKAN_HPP_NOEXCEPT;
5444 
5445  void setLineWidth( float lineWidth ) const VULKAN_HPP_NOEXCEPT;
5446 
5447  void setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor ) const VULKAN_HPP_NOEXCEPT;
5448 
5449  void setBlendConstants( const float blendConstants[4] ) const VULKAN_HPP_NOEXCEPT;
5450 
5451  void setDepthBounds( float minDepthBounds, float maxDepthBounds ) const VULKAN_HPP_NOEXCEPT;
5452 
5453  void setStencilCompareMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t compareMask ) const VULKAN_HPP_NOEXCEPT;
5454 
5455  void setStencilWriteMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t writeMask ) const VULKAN_HPP_NOEXCEPT;
5456 
5457  void setStencilReference( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t reference ) const VULKAN_HPP_NOEXCEPT;
5458 
5459  void bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
5460  VULKAN_HPP_NAMESPACE::PipelineLayout layout,
5461  uint32_t firstSet,
5462  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
5463  VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & dynamicOffsets ) const VULKAN_HPP_NOEXCEPT;
5464 
5465  void bindIndexBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer,
5468 
5469  void bindVertexBuffers( uint32_t firstBinding,
5470  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers,
5471  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets ) const;
5472 
5473  void draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT;
5474 
5475  void
5476  drawIndexed( uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT;
5477 
5478  void drawIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer,
5480  uint32_t drawCount,
5481  uint32_t stride ) const VULKAN_HPP_NOEXCEPT;
5482 
5483  void drawIndexedIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer,
5485  uint32_t drawCount,
5486  uint32_t stride ) const VULKAN_HPP_NOEXCEPT;
5487 
5488  void dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT;
5489 
5490  void dispatchIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset ) const VULKAN_HPP_NOEXCEPT;
5491 
5492  void copyBuffer( VULKAN_HPP_NAMESPACE::Buffer srcBuffer,
5493  VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
5494  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferCopy> const & regions ) const VULKAN_HPP_NOEXCEPT;
5495 
5496  void copyImage( VULKAN_HPP_NAMESPACE::Image srcImage,
5497  VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
5498  VULKAN_HPP_NAMESPACE::Image dstImage,
5499  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
5500  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageCopy> const & regions ) const VULKAN_HPP_NOEXCEPT;
5501 
5502  void blitImage( VULKAN_HPP_NAMESPACE::Image srcImage,
5503  VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
5504  VULKAN_HPP_NAMESPACE::Image dstImage,
5505  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
5506  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageBlit> const & regions,
5508 
5509  void copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer srcBuffer,
5510  VULKAN_HPP_NAMESPACE::Image dstImage,
5511  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
5512  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions ) const VULKAN_HPP_NOEXCEPT;
5513 
5514  void copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image srcImage,
5515  VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
5516  VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
5517  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions ) const VULKAN_HPP_NOEXCEPT;
5518 
5519  template <typename DataType>
5520  void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
5522  VULKAN_HPP_NAMESPACE::ArrayProxy<const DataType> const & data ) const VULKAN_HPP_NOEXCEPT;
5523 
5524  void fillBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
5527  uint32_t data ) const VULKAN_HPP_NOEXCEPT;
5528 
5529  void clearColorImage( VULKAN_HPP_NAMESPACE::Image image,
5531  const VULKAN_HPP_NAMESPACE::ClearColorValue & color,
5532  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges ) const VULKAN_HPP_NOEXCEPT;
5533 
5534  void
5535  clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image image,
5537  const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue & depthStencil,
5538  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges ) const VULKAN_HPP_NOEXCEPT;
5539 
5540  void clearAttachments( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearAttachment> const & attachments,
5541  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearRect> const & rects ) const VULKAN_HPP_NOEXCEPT;
5542 
5543  void resolveImage( VULKAN_HPP_NAMESPACE::Image srcImage,
5544  VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
5545  VULKAN_HPP_NAMESPACE::Image dstImage,
5546  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
5547  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageResolve> const & regions ) const VULKAN_HPP_NOEXCEPT;
5548 
5549  void setEvent( VULKAN_HPP_NAMESPACE::Event event,
5551 
5552  void resetEvent( VULKAN_HPP_NAMESPACE::Event event,
5554 
5555  void waitEvents( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events,
5558  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const & memoryBarriers,
5559  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,
5560  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const & imageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT;
5561 
5562  void pipelineBarrier( VULKAN_HPP_NAMESPACE::PipelineStageFlags srcStageMask,
5564  VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags,
5565  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const & memoryBarriers,
5566  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,
5567  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const & imageMemoryBarriers ) const
5569 
5570  void beginQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
5571  uint32_t query,
5573 
5574  void endQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT;
5575 
5576  void resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT;
5577 
5578  void writeTimestamp( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,
5579  VULKAN_HPP_NAMESPACE::QueryPool queryPool,
5580  uint32_t query ) const VULKAN_HPP_NOEXCEPT;
5581 
5582  void copyQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
5583  uint32_t firstQuery,
5584  uint32_t queryCount,
5585  VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
5589 
5590  template <typename ValuesType>
5591  void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout layout,
5593  uint32_t offset,
5594  VULKAN_HPP_NAMESPACE::ArrayProxy<const ValuesType> const & values ) const VULKAN_HPP_NOEXCEPT;
5595 
5596  void beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,
5598 
5599  void nextSubpass( VULKAN_HPP_NAMESPACE::SubpassContents contents ) const VULKAN_HPP_NOEXCEPT;
5600 
5601  void endRenderPass() const VULKAN_HPP_NOEXCEPT;
5602 
5603  void executeCommands( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers ) const VULKAN_HPP_NOEXCEPT;
5604 
5605  //=== VK_VERSION_1_1 ===
5606 
5607  void setDeviceMask( uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT;
5608 
5609  void dispatchBase( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const
5611 
5612  //=== VK_VERSION_1_2 ===
5613 
5614  void drawIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer,
5615  VULKAN_HPP_NAMESPACE::DeviceSize offset,
5616  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
5617  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
5618  uint32_t maxDrawCount,
5619  uint32_t stride ) const VULKAN_HPP_NOEXCEPT;
5620 
5621  void drawIndexedIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer,
5622  VULKAN_HPP_NAMESPACE::DeviceSize offset,
5623  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
5624  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
5625  uint32_t maxDrawCount,
5626  uint32_t stride ) const VULKAN_HPP_NOEXCEPT;
5627 
5628  void beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,
5629  const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT;
5630 
5631  void nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo,
5632  const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT;
5633 
5634  void endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT;
5635 
5636  //=== VK_VERSION_1_3 ===
5637 
5638  void setEvent2( VULKAN_HPP_NAMESPACE::Event event, const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT;
5639 
5640  void resetEvent2( VULKAN_HPP_NAMESPACE::Event event,
5641  VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stageMask VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5642 
5643  void waitEvents2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events,
5644  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfo> const & dependencyInfos ) const;
5645 
5646  void pipelineBarrier2( const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT;
5647 
5648  void
5649  writeTimestamp2( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT;
5650 
5651  void copyBuffer2( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo ) const VULKAN_HPP_NOEXCEPT;
5652 
5653  void copyImage2( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo ) const VULKAN_HPP_NOEXCEPT;
5654 
5655  void copyBufferToImage2( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT;
5656 
5657  void copyImageToBuffer2( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT;
5658 
5659  void blitImage2( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo ) const VULKAN_HPP_NOEXCEPT;
5660 
5661  void resolveImage2( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo ) const VULKAN_HPP_NOEXCEPT;
5662 
5663  void beginRendering( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo ) const VULKAN_HPP_NOEXCEPT;
5664 
5665  void endRendering() const VULKAN_HPP_NOEXCEPT;
5666 
5667  void setCullMode( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
5668 
5669  void setFrontFace( VULKAN_HPP_NAMESPACE::FrontFace frontFace ) const VULKAN_HPP_NOEXCEPT;
5670 
5671  void setPrimitiveTopology( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT;
5672 
5673  void setViewportWithCount( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports ) const VULKAN_HPP_NOEXCEPT;
5674 
5675  void setScissorWithCount( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors ) const VULKAN_HPP_NOEXCEPT;
5676 
5677  void bindVertexBuffers2(
5678  uint32_t firstBinding,
5679  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers,
5680  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
5681  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
5682  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const;
5683 
5684  void setDepthTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT;
5685 
5686  void setDepthWriteEnable( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT;
5687 
5688  void setDepthCompareOp( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT;
5689 
5690  void setDepthBoundsTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT;
5691 
5692  void setStencilTestEnable( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT;
5693 
5694  void setStencilOp( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
5695  VULKAN_HPP_NAMESPACE::StencilOp failOp,
5696  VULKAN_HPP_NAMESPACE::StencilOp passOp,
5697  VULKAN_HPP_NAMESPACE::StencilOp depthFailOp,
5698  VULKAN_HPP_NAMESPACE::CompareOp compareOp ) const VULKAN_HPP_NOEXCEPT;
5699 
5700  void setRasterizerDiscardEnable( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT;
5701 
5702  void setDepthBiasEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT;
5703 
5704  void setPrimitiveRestartEnable( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT;
5705 
5706  //=== VK_EXT_debug_marker ===
5707 
5708  void debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo ) const VULKAN_HPP_NOEXCEPT;
5709 
5710  void debugMarkerEndEXT() const VULKAN_HPP_NOEXCEPT;
5711 
5712  void debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo ) const VULKAN_HPP_NOEXCEPT;
5713 
5714  //=== VK_KHR_video_queue ===
5715 
5716  void beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR & beginInfo ) const VULKAN_HPP_NOEXCEPT;
5717 
5718  void endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR & endCodingInfo ) const VULKAN_HPP_NOEXCEPT;
5719 
5720  void controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR & codingControlInfo ) const VULKAN_HPP_NOEXCEPT;
5721 
5722  //=== VK_KHR_video_decode_queue ===
5723 
5724  void decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR & decodeInfo ) const VULKAN_HPP_NOEXCEPT;
5725 
5726  //=== VK_EXT_transform_feedback ===
5727 
5728  void bindTransformFeedbackBuffersEXT( uint32_t firstBinding,
5729  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers,
5730  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
5731  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes
5733 
5734  void beginTransformFeedbackEXT( uint32_t firstCounterBuffer,
5735  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers,
5736  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets
5738 
5739  void endTransformFeedbackEXT( uint32_t firstCounterBuffer,
5740  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers,
5741  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets
5743 
5744  void beginQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
5745  uint32_t query,
5746  VULKAN_HPP_NAMESPACE::QueryControlFlags flags,
5747  uint32_t index ) const VULKAN_HPP_NOEXCEPT;
5748 
5749  void endQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, uint32_t index ) const VULKAN_HPP_NOEXCEPT;
5750 
5751  void drawIndirectByteCountEXT( uint32_t instanceCount,
5752  uint32_t firstInstance,
5753  VULKAN_HPP_NAMESPACE::Buffer counterBuffer,
5754  VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset,
5755  uint32_t counterOffset,
5756  uint32_t vertexStride ) const VULKAN_HPP_NOEXCEPT;
5757 
5758  //=== VK_NVX_binary_import ===
5759 
5760  void cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX & launchInfo ) const VULKAN_HPP_NOEXCEPT;
5761 
5762  //=== VK_AMD_draw_indirect_count ===
5763 
5764  void drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer,
5765  VULKAN_HPP_NAMESPACE::DeviceSize offset,
5766  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
5767  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
5768  uint32_t maxDrawCount,
5769  uint32_t stride ) const VULKAN_HPP_NOEXCEPT;
5770 
5771  void drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer,
5772  VULKAN_HPP_NAMESPACE::DeviceSize offset,
5773  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
5774  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
5775  uint32_t maxDrawCount,
5776  uint32_t stride ) const VULKAN_HPP_NOEXCEPT;
5777 
5778  //=== VK_KHR_dynamic_rendering ===
5779 
5780  void beginRenderingKHR( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo ) const VULKAN_HPP_NOEXCEPT;
5781 
5782  void endRenderingKHR() const VULKAN_HPP_NOEXCEPT;
5783 
5784  //=== VK_KHR_device_group ===
5785 
5786  void setDeviceMaskKHR( uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT;
5787 
5788  void dispatchBaseKHR( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ )
5789  const VULKAN_HPP_NOEXCEPT;
5790 
5791  //=== VK_KHR_push_descriptor ===
5792 
5793  void pushDescriptorSetKHR( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
5794  VULKAN_HPP_NAMESPACE::PipelineLayout layout,
5795  uint32_t set,
5796  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites ) const
5798 
5799  template <typename DataType>
5800  void pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
5801  VULKAN_HPP_NAMESPACE::PipelineLayout layout,
5802  uint32_t set,
5803  DataType const & data ) const VULKAN_HPP_NOEXCEPT;
5804 
5805  //=== VK_EXT_conditional_rendering ===
5806 
5807  void beginConditionalRenderingEXT( const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin ) const VULKAN_HPP_NOEXCEPT;
5808 
5809  void endConditionalRenderingEXT() const VULKAN_HPP_NOEXCEPT;
5810 
5811  //=== VK_NV_clip_space_w_scaling ===
5812 
5813  void setViewportWScalingNV( uint32_t firstViewport,
5814  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportWScalingNV> const & viewportWScalings ) const
5816 
5817  //=== VK_EXT_discard_rectangles ===
5818 
5819  void setDiscardRectangleEXT( uint32_t firstDiscardRectangle,
5820  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & discardRectangles ) const VULKAN_HPP_NOEXCEPT;
5821 
5822  void setDiscardRectangleEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 discardRectangleEnable ) const VULKAN_HPP_NOEXCEPT;
5823 
5824  void setDiscardRectangleModeEXT( VULKAN_HPP_NAMESPACE::DiscardRectangleModeEXT discardRectangleMode ) const VULKAN_HPP_NOEXCEPT;
5825 
5826  //=== VK_KHR_create_renderpass2 ===
5827 
5828  void beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,
5829  const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT;
5830 
5831  void nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo,
5832  const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT;
5833 
5834  void endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT;
5835 
5836  //=== VK_EXT_debug_utils ===
5837 
5838  void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT;
5839 
5840  void endDebugUtilsLabelEXT() const VULKAN_HPP_NOEXCEPT;
5841 
5842  void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT;
5843 
5844 # if defined( VK_ENABLE_BETA_EXTENSIONS )
5845  //=== VK_AMDX_shader_enqueue ===
5846 
5847  void initializeGraphScratchMemoryAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch ) const VULKAN_HPP_NOEXCEPT;
5848 
5849  void dispatchGraphAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch,
5850  const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX & countInfo ) const VULKAN_HPP_NOEXCEPT;
5851 
5852  void dispatchGraphIndirectAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch,
5853  const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX & countInfo ) const VULKAN_HPP_NOEXCEPT;
5854 
5855  void dispatchGraphIndirectCountAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch,
5857 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
5858 
5859  //=== VK_EXT_sample_locations ===
5860 
5861  void setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT & sampleLocationsInfo ) const VULKAN_HPP_NOEXCEPT;
5862 
5863  //=== VK_KHR_acceleration_structure ===
5864 
5865  void buildAccelerationStructuresKHR(
5866  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,
5867  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos ) const;
5868 
5869  void buildAccelerationStructuresIndirectKHR(
5870  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,
5871  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceAddress> const & indirectDeviceAddresses,
5872  VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & indirectStrides,
5873  VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t * const> const & pMaxPrimitiveCounts ) const;
5874 
5875  void copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info ) const VULKAN_HPP_NOEXCEPT;
5876 
5877  void copyAccelerationStructureToMemoryKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info ) const VULKAN_HPP_NOEXCEPT;
5878 
5879  void copyMemoryToAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info ) const VULKAN_HPP_NOEXCEPT;
5880 
5881  void writeAccelerationStructuresPropertiesKHR(
5882  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
5884  VULKAN_HPP_NAMESPACE::QueryPool queryPool,
5885  uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT;
5886 
5887  //=== VK_KHR_ray_tracing_pipeline ===
5888 
5889  void traceRaysKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
5890  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable,
5891  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable,
5892  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable,
5893  uint32_t width,
5894  uint32_t height,
5895  uint32_t depth ) const VULKAN_HPP_NOEXCEPT;
5896 
5897  void traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
5898  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable,
5899  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable,
5900  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable,
5901  VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT;
5902 
5903  void setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize ) const VULKAN_HPP_NOEXCEPT;
5904 
5905  //=== VK_NV_shading_rate_image ===
5906 
5907  void bindShadingRateImageNV( VULKAN_HPP_NAMESPACE::ImageView imageView, VULKAN_HPP_NAMESPACE::ImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT;
5908 
5909  void setViewportShadingRatePaletteNV(
5910  uint32_t firstViewport,
5911  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> const & shadingRatePalettes ) const VULKAN_HPP_NOEXCEPT;
5912 
5913  void setCoarseSampleOrderNV( VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV sampleOrderType,
5914  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> const & customSampleOrders ) const
5916 
5917  //=== VK_NV_ray_tracing ===
5918 
5919  void buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV & info,
5920  VULKAN_HPP_NAMESPACE::Buffer instanceData,
5921  VULKAN_HPP_NAMESPACE::DeviceSize instanceOffset,
5923  VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst,
5924  VULKAN_HPP_NAMESPACE::AccelerationStructureNV src,
5925  VULKAN_HPP_NAMESPACE::Buffer scratch,
5927 
5928  void copyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst,
5929  VULKAN_HPP_NAMESPACE::AccelerationStructureNV src,
5931 
5932  void traceRaysNV( VULKAN_HPP_NAMESPACE::Buffer raygenShaderBindingTableBuffer,
5933  VULKAN_HPP_NAMESPACE::DeviceSize raygenShaderBindingOffset,
5934  VULKAN_HPP_NAMESPACE::Buffer missShaderBindingTableBuffer,
5935  VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingOffset,
5936  VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingStride,
5937  VULKAN_HPP_NAMESPACE::Buffer hitShaderBindingTableBuffer,
5938  VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingOffset,
5939  VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingStride,
5940  VULKAN_HPP_NAMESPACE::Buffer callableShaderBindingTableBuffer,
5941  VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingOffset,
5942  VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingStride,
5943  uint32_t width,
5944  uint32_t height,
5945  uint32_t depth ) const VULKAN_HPP_NOEXCEPT;
5946 
5947  void writeAccelerationStructuresPropertiesNV(
5948  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureNV> const & accelerationStructures,
5950  VULKAN_HPP_NAMESPACE::QueryPool queryPool,
5951  uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT;
5952 
5953  //=== VK_KHR_draw_indirect_count ===
5954 
5955  void drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer,
5957  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
5958  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
5959  uint32_t maxDrawCount,
5960  uint32_t stride ) const VULKAN_HPP_NOEXCEPT;
5961 
5962  void drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer,
5964  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
5965  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
5966  uint32_t maxDrawCount,
5967  uint32_t stride ) const VULKAN_HPP_NOEXCEPT;
5968 
5969  //=== VK_AMD_buffer_marker ===
5970 
5971  void writeBufferMarkerAMD( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,
5972  VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
5974  uint32_t marker ) const VULKAN_HPP_NOEXCEPT;
5975 
5976  //=== VK_NV_mesh_shader ===
5977 
5978  void drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask ) const VULKAN_HPP_NOEXCEPT;
5979 
5980  void drawMeshTasksIndirectNV( VULKAN_HPP_NAMESPACE::Buffer buffer,
5982  uint32_t drawCount,
5983  uint32_t stride ) const VULKAN_HPP_NOEXCEPT;
5984 
5985  void drawMeshTasksIndirectCountNV( VULKAN_HPP_NAMESPACE::Buffer buffer,
5987  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
5988  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
5989  uint32_t maxDrawCount,
5990  uint32_t stride ) const VULKAN_HPP_NOEXCEPT;
5991 
5992  //=== VK_NV_scissor_exclusive ===
5993 
5994  void setExclusiveScissorEnableNV( uint32_t firstExclusiveScissor,
5995  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & exclusiveScissorEnables ) const
5997 
5998  void setExclusiveScissorNV( uint32_t firstExclusiveScissor,
5999  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & exclusiveScissors ) const VULKAN_HPP_NOEXCEPT;
6000 
6001  //=== VK_NV_device_diagnostic_checkpoints ===
6002 
6003  template <typename CheckpointMarkerType>
6004  void setCheckpointNV( CheckpointMarkerType const & checkpointMarker ) const VULKAN_HPP_NOEXCEPT;
6005 
6006  //=== VK_INTEL_performance_query ===
6007 
6008  void setPerformanceMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL & markerInfo ) const;
6009 
6010  void setPerformanceStreamMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL & markerInfo ) const;
6011 
6012  void setPerformanceOverrideINTEL( const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL & overrideInfo ) const;
6013 
6014  //=== VK_KHR_fragment_shading_rate ===
6015 
6016  void setFragmentShadingRateKHR( const VULKAN_HPP_NAMESPACE::Extent2D & fragmentSize,
6018 
6019  //=== VK_EXT_line_rasterization ===
6020 
6021  void setLineStippleEXT( uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT;
6022 
6023  //=== VK_EXT_extended_dynamic_state ===
6024 
6026 
6027  void setFrontFaceEXT( VULKAN_HPP_NAMESPACE::FrontFace frontFace ) const VULKAN_HPP_NOEXCEPT;
6028 
6029  void setPrimitiveTopologyEXT( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT;
6030 
6031  void setViewportWithCountEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports ) const VULKAN_HPP_NOEXCEPT;
6032 
6033  void setScissorWithCountEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors ) const VULKAN_HPP_NOEXCEPT;
6034 
6036  uint32_t firstBinding,
6037  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers,
6038  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
6039  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
6040  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT ) const;
6041 
6042  void setDepthTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT;
6043 
6044  void setDepthWriteEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT;
6045 
6046  void setDepthCompareOpEXT( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT;
6047 
6048  void setDepthBoundsTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT;
6049 
6050  void setStencilTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT;
6051 
6052  void setStencilOpEXT( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
6055  VULKAN_HPP_NAMESPACE::StencilOp depthFailOp,
6057 
6058  //=== VK_NV_device_generated_commands ===
6059 
6060  void preprocessGeneratedCommandsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo ) const VULKAN_HPP_NOEXCEPT;
6061 
6062  void executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32 isPreprocessed,
6063  const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo ) const VULKAN_HPP_NOEXCEPT;
6064 
6065  void bindPipelineShaderGroupNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
6066  VULKAN_HPP_NAMESPACE::Pipeline pipeline,
6067  uint32_t groupIndex ) const VULKAN_HPP_NOEXCEPT;
6068 
6069  //=== VK_EXT_depth_bias_control ===
6070 
6071  void setDepthBias2EXT( const VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT & depthBiasInfo ) const VULKAN_HPP_NOEXCEPT;
6072 
6073  //=== VK_KHR_video_encode_queue ===
6074 
6075  void encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR & encodeInfo ) const VULKAN_HPP_NOEXCEPT;
6076 
6077 # if defined( VK_ENABLE_BETA_EXTENSIONS )
6078  //=== VK_NV_cuda_kernel_launch ===
6079 
6080  void cudaLaunchKernelNV( const VULKAN_HPP_NAMESPACE::CudaLaunchInfoNV & launchInfo ) const VULKAN_HPP_NOEXCEPT;
6081 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
6082 
6083  //=== VK_KHR_synchronization2 ===
6084 
6085  void setEvent2KHR( VULKAN_HPP_NAMESPACE::Event event, const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT;
6086 
6087  void resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event event,
6089 
6090  void waitEvents2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events,
6091  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfo> const & dependencyInfos ) const;
6092 
6093  void pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT;
6094 
6095  void writeTimestamp2KHR( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage,
6096  VULKAN_HPP_NAMESPACE::QueryPool queryPool,
6097  uint32_t query ) const VULKAN_HPP_NOEXCEPT;
6098 
6099  void writeBufferMarker2AMD( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage,
6100  VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
6102  uint32_t marker ) const VULKAN_HPP_NOEXCEPT;
6103 
6104  //=== VK_EXT_descriptor_buffer ===
6105 
6106  void bindDescriptorBuffersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT> const & bindingInfos ) const
6108 
6109  void setDescriptorBufferOffsetsEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
6110  VULKAN_HPP_NAMESPACE::PipelineLayout layout,
6111  uint32_t firstSet,
6112  VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & bufferIndices,
6113  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets ) const;
6114 
6115  void bindDescriptorBufferEmbeddedSamplersEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
6116  VULKAN_HPP_NAMESPACE::PipelineLayout layout,
6117  uint32_t set ) const VULKAN_HPP_NOEXCEPT;
6118 
6119  //=== VK_NV_fragment_shading_rate_enums ===
6120 
6121  void setFragmentShadingRateEnumNV( VULKAN_HPP_NAMESPACE::FragmentShadingRateNV shadingRate,
6123 
6124  //=== VK_EXT_mesh_shader ===
6125 
6126  void drawMeshTasksEXT( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT;
6127 
6128  void drawMeshTasksIndirectEXT( VULKAN_HPP_NAMESPACE::Buffer buffer,
6130  uint32_t drawCount,
6131  uint32_t stride ) const VULKAN_HPP_NOEXCEPT;
6132 
6133  void drawMeshTasksIndirectCountEXT( VULKAN_HPP_NAMESPACE::Buffer buffer,
6135  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
6136  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
6137  uint32_t maxDrawCount,
6138  uint32_t stride ) const VULKAN_HPP_NOEXCEPT;
6139 
6140  //=== VK_KHR_copy_commands2 ===
6141 
6142  void copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo ) const VULKAN_HPP_NOEXCEPT;
6143 
6144  void copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo ) const VULKAN_HPP_NOEXCEPT;
6145 
6146  void copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT;
6147 
6148  void copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT;
6149 
6150  void blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo ) const VULKAN_HPP_NOEXCEPT;
6151 
6152  void resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo ) const VULKAN_HPP_NOEXCEPT;
6153 
6154  //=== VK_EXT_vertex_input_dynamic_state ===
6155 
6156  void setVertexInputEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT> const & vertexBindingDescriptions,
6157  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT> const &
6158  vertexAttributeDescriptions ) const VULKAN_HPP_NOEXCEPT;
6159 
6160  //=== VK_HUAWEI_subpass_shading ===
6161 
6162  void subpassShadingHUAWEI() const VULKAN_HPP_NOEXCEPT;
6163 
6164  //=== VK_HUAWEI_invocation_mask ===
6165 
6166  void bindInvocationMaskHUAWEI( VULKAN_HPP_NAMESPACE::ImageView imageView, VULKAN_HPP_NAMESPACE::ImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT;
6167 
6168  //=== VK_EXT_extended_dynamic_state2 ===
6169 
6170  void setPatchControlPointsEXT( uint32_t patchControlPoints ) const VULKAN_HPP_NOEXCEPT;
6171 
6172  void setRasterizerDiscardEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT;
6173 
6174  void setDepthBiasEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT;
6175 
6176  void setLogicOpEXT( VULKAN_HPP_NAMESPACE::LogicOp logicOp ) const VULKAN_HPP_NOEXCEPT;
6177 
6178  void setPrimitiveRestartEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT;
6179 
6180  //=== VK_EXT_color_write_enable ===
6181 
6182  void setColorWriteEnableEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorWriteEnables ) const VULKAN_HPP_NOEXCEPT;
6183 
6184  //=== VK_KHR_ray_tracing_maintenance1 ===
6185 
6186  void traceRaysIndirect2KHR( VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT;
6187 
6188  //=== VK_EXT_multi_draw ===
6189 
6190  void drawMultiEXT( VULKAN_HPP_NAMESPACE::StridedArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT> const & vertexInfo,
6191  uint32_t instanceCount,
6192  uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT;
6193 
6194  void drawMultiIndexedEXT( VULKAN_HPP_NAMESPACE::StridedArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT> const & indexInfo,
6195  uint32_t instanceCount,
6196  uint32_t firstInstance,
6198 
6199  //=== VK_EXT_opacity_micromap ===
6200 
6201  void buildMicromapsEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT> const & infos ) const VULKAN_HPP_NOEXCEPT;
6202 
6203  void copyMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT & info ) const VULKAN_HPP_NOEXCEPT;
6204 
6205  void copyMicromapToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT & info ) const VULKAN_HPP_NOEXCEPT;
6206 
6207  void copyMemoryToMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT & info ) const VULKAN_HPP_NOEXCEPT;
6208 
6209  void writeMicromapsPropertiesEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps,
6210  VULKAN_HPP_NAMESPACE::QueryType queryType,
6211  VULKAN_HPP_NAMESPACE::QueryPool queryPool,
6212  uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT;
6213 
6214  //=== VK_HUAWEI_cluster_culling_shader ===
6215 
6216  void drawClusterHUAWEI( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT;
6217 
6218  void drawClusterIndirectHUAWEI( VULKAN_HPP_NAMESPACE::Buffer buffer, VULKAN_HPP_NAMESPACE::DeviceSize offset ) const VULKAN_HPP_NOEXCEPT;
6219 
6220  //=== VK_NV_copy_memory_indirect ===
6221 
6222  void copyMemoryIndirectNV( VULKAN_HPP_NAMESPACE::DeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT;
6223 
6224  void copyMemoryToImageIndirectNV( VULKAN_HPP_NAMESPACE::DeviceAddress copyBufferAddress,
6225  uint32_t stride,
6226  VULKAN_HPP_NAMESPACE::Image dstImage,
6227  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
6228  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceLayers> const & imageSubresources ) const
6230 
6231  //=== VK_NV_memory_decompression ===
6232 
6233  void decompressMemoryNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV> const & decompressMemoryRegions ) const
6235 
6236  void decompressMemoryIndirectCountNV( VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsAddress,
6237  VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsCountAddress,
6238  uint32_t stride ) const VULKAN_HPP_NOEXCEPT;
6239 
6240  //=== VK_NV_device_generated_commands_compute ===
6241 
6242  void updatePipelineIndirectBufferNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
6243  VULKAN_HPP_NAMESPACE::Pipeline pipeline ) const VULKAN_HPP_NOEXCEPT;
6244 
6245  //=== VK_EXT_extended_dynamic_state3 ===
6246 
6247  void setTessellationDomainOriginEXT( VULKAN_HPP_NAMESPACE::TessellationDomainOrigin domainOrigin ) const VULKAN_HPP_NOEXCEPT;
6248 
6249  void setDepthClampEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClampEnable ) const VULKAN_HPP_NOEXCEPT;
6250 
6251  void setPolygonModeEXT( VULKAN_HPP_NAMESPACE::PolygonMode polygonMode ) const VULKAN_HPP_NOEXCEPT;
6252 
6253  void setRasterizationSamplesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits rasterizationSamples ) const VULKAN_HPP_NOEXCEPT;
6254 
6255  void setSampleMaskEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
6256  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SampleMask> const & sampleMask ) const;
6257 
6258  void setAlphaToCoverageEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 alphaToCoverageEnable ) const VULKAN_HPP_NOEXCEPT;
6259 
6260  void setAlphaToOneEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 alphaToOneEnable ) const VULKAN_HPP_NOEXCEPT;
6261 
6262  void setLogicOpEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 logicOpEnable ) const VULKAN_HPP_NOEXCEPT;
6263 
6264  void setColorBlendEnableEXT( uint32_t firstAttachment,
6265  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorBlendEnables ) const VULKAN_HPP_NOEXCEPT;
6266 
6267  void setColorBlendEquationEXT( uint32_t firstAttachment,
6268  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT> const & colorBlendEquations ) const
6270 
6271  void setColorWriteMaskEXT( uint32_t firstAttachment,
6272  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorComponentFlags> const & colorWriteMasks ) const
6274 
6275  void setRasterizationStreamEXT( uint32_t rasterizationStream ) const VULKAN_HPP_NOEXCEPT;
6276 
6277  void
6278  setConservativeRasterizationModeEXT( VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT conservativeRasterizationMode ) const VULKAN_HPP_NOEXCEPT;
6279 
6280  void setExtraPrimitiveOverestimationSizeEXT( float extraPrimitiveOverestimationSize ) const VULKAN_HPP_NOEXCEPT;
6281 
6282  void setDepthClipEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClipEnable ) const VULKAN_HPP_NOEXCEPT;
6283 
6284  void setSampleLocationsEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 sampleLocationsEnable ) const VULKAN_HPP_NOEXCEPT;
6285 
6286  void setColorBlendAdvancedEXT( uint32_t firstAttachment,
6287  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT> const & colorBlendAdvanced ) const
6289 
6290  void setProvokingVertexModeEXT( VULKAN_HPP_NAMESPACE::ProvokingVertexModeEXT provokingVertexMode ) const VULKAN_HPP_NOEXCEPT;
6291 
6292  void setLineRasterizationModeEXT( VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT lineRasterizationMode ) const VULKAN_HPP_NOEXCEPT;
6293 
6294  void setLineStippleEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stippledLineEnable ) const VULKAN_HPP_NOEXCEPT;
6295 
6296  void setDepthClipNegativeOneToOneEXT( VULKAN_HPP_NAMESPACE::Bool32 negativeOneToOne ) const VULKAN_HPP_NOEXCEPT;
6297 
6298  void setViewportWScalingEnableNV( VULKAN_HPP_NAMESPACE::Bool32 viewportWScalingEnable ) const VULKAN_HPP_NOEXCEPT;
6299 
6300  void setViewportSwizzleNV( uint32_t firstViewport,
6301  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV> const & viewportSwizzles ) const
6303 
6304  void setCoverageToColorEnableNV( VULKAN_HPP_NAMESPACE::Bool32 coverageToColorEnable ) const VULKAN_HPP_NOEXCEPT;
6305 
6306  void setCoverageToColorLocationNV( uint32_t coverageToColorLocation ) const VULKAN_HPP_NOEXCEPT;
6307 
6308  void setCoverageModulationModeNV( VULKAN_HPP_NAMESPACE::CoverageModulationModeNV coverageModulationMode ) const VULKAN_HPP_NOEXCEPT;
6309 
6310  void setCoverageModulationTableEnableNV( VULKAN_HPP_NAMESPACE::Bool32 coverageModulationTableEnable ) const VULKAN_HPP_NOEXCEPT;
6311 
6312  void setCoverageModulationTableNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const float> const & coverageModulationTable ) const VULKAN_HPP_NOEXCEPT;
6313 
6314  void setShadingRateImageEnableNV( VULKAN_HPP_NAMESPACE::Bool32 shadingRateImageEnable ) const VULKAN_HPP_NOEXCEPT;
6315 
6316  void setRepresentativeFragmentTestEnableNV( VULKAN_HPP_NAMESPACE::Bool32 representativeFragmentTestEnable ) const VULKAN_HPP_NOEXCEPT;
6317 
6318  void setCoverageReductionModeNV( VULKAN_HPP_NAMESPACE::CoverageReductionModeNV coverageReductionMode ) const VULKAN_HPP_NOEXCEPT;
6319 
6320  //=== VK_NV_optical_flow ===
6321 
6322  void opticalFlowExecuteNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session,
6323  const VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV & executeInfo ) const VULKAN_HPP_NOEXCEPT;
6324 
6325  //=== VK_KHR_maintenance5 ===
6326 
6327  void bindIndexBuffer2KHR( VULKAN_HPP_NAMESPACE::Buffer buffer,
6328  VULKAN_HPP_NAMESPACE::DeviceSize offset,
6329  VULKAN_HPP_NAMESPACE::DeviceSize size,
6330  VULKAN_HPP_NAMESPACE::IndexType indexType ) const VULKAN_HPP_NOEXCEPT;
6331 
6332  //=== VK_EXT_shader_object ===
6333 
6334  void bindShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderStageFlagBits> const & stages,
6335  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderEXT> const & shaders ) const;
6336 
6337  //=== VK_EXT_attachment_feedback_loop_dynamic_state ===
6338 
6339  void setAttachmentFeedbackLoopEnableEXT( VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const
6341 
6342  //=== VK_KHR_maintenance6 ===
6343 
6344  void bindDescriptorSets2KHR( const VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfoKHR & bindDescriptorSetsInfo ) const VULKAN_HPP_NOEXCEPT;
6345 
6346  void pushConstants2KHR( const VULKAN_HPP_NAMESPACE::PushConstantsInfoKHR & pushConstantsInfo ) const VULKAN_HPP_NOEXCEPT;
6347 
6348  void pushDescriptorSet2KHR( const VULKAN_HPP_NAMESPACE::PushDescriptorSetInfoKHR & pushDescriptorSetInfo ) const VULKAN_HPP_NOEXCEPT;
6349 
6350  void pushDescriptorSetWithTemplate2KHR( const VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfoKHR & pushDescriptorSetWithTemplateInfo ) const
6352 
6353  void setDescriptorBufferOffsets2EXT( const VULKAN_HPP_NAMESPACE::SetDescriptorBufferOffsetsInfoEXT & setDescriptorBufferOffsetsInfo ) const
6355 
6356  void bindDescriptorBufferEmbeddedSamplers2EXT(
6357  const VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT & bindDescriptorBufferEmbeddedSamplersInfo ) const VULKAN_HPP_NOEXCEPT;
6358 
6359  private:
6360  VULKAN_HPP_NAMESPACE::Device m_device = {};
6361  VULKAN_HPP_NAMESPACE::CommandPool m_commandPool = {};
6362  VULKAN_HPP_NAMESPACE::CommandBuffer m_commandBuffer = {};
6363  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
6364  };
6365 
6366  class CommandBuffers : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CommandBuffer>
6367  {
6368  public:
6369 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
6370  CommandBuffers( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
6371  VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo const & allocateInfo )
6372  {
6373  *this = device.allocateCommandBuffers( allocateInfo );
6374  }
6375 # endif
6376 
6377  CommandBuffers( std::nullptr_t ) {}
6378 
6379  CommandBuffers() = delete;
6380  CommandBuffers( CommandBuffers const & ) = delete;
6381  CommandBuffers( CommandBuffers && rhs ) = default;
6382  CommandBuffers & operator=( CommandBuffers const & ) = delete;
6383  CommandBuffers & operator=( CommandBuffers && rhs ) = default;
6384 
6385  private:
6386  CommandBuffers( std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CommandBuffer> && rhs )
6387  {
6388  std::swap( *this, rhs );
6389  }
6390  };
6391 
6393  {
6394  public:
6397 
6398  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCuFunctionNVX;
6400  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuFunctionNVX;
6401 
6402  public:
6403 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
6404  CuFunctionNVX( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
6405  VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX const & createInfo,
6406  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
6407  {
6408  *this = device.createCuFunctionNVX( createInfo, allocator );
6409  }
6410 # endif
6411 
6412  CuFunctionNVX( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
6413  VkCuFunctionNVX function,
6414  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
6415  : m_device( device )
6416  , m_function( function )
6417  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
6418  , m_dispatcher( device.getDispatcher() )
6419  {
6420  }
6421 
6422  CuFunctionNVX( std::nullptr_t ) {}
6423 
6425  {
6426  clear();
6427  }
6428 
6429  CuFunctionNVX() = delete;
6430  CuFunctionNVX( CuFunctionNVX const & ) = delete;
6431 
6433  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
6434  , m_function( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_function, {} ) )
6435  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
6436  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
6437  {
6438  }
6439 
6440  CuFunctionNVX & operator=( CuFunctionNVX const & ) = delete;
6441 
6443  {
6444  if ( this != &rhs )
6445  {
6446  std::swap( m_device, rhs.m_device );
6447  std::swap( m_function, rhs.m_function );
6448  std::swap( m_allocator, rhs.m_allocator );
6449  std::swap( m_dispatcher, rhs.m_dispatcher );
6450  }
6451  return *this;
6452  }
6453 
6454  VULKAN_HPP_NAMESPACE::CuFunctionNVX const & operator*() const VULKAN_HPP_NOEXCEPT
6455  {
6456  return m_function;
6457  }
6458 
6459  operator VULKAN_HPP_NAMESPACE::CuFunctionNVX() const VULKAN_HPP_NOEXCEPT
6460  {
6461  return m_function;
6462  }
6463 
6465  {
6466  if ( m_function )
6467  {
6468  getDispatcher()->vkDestroyCuFunctionNVX(
6469  static_cast<VkDevice>( m_device ), static_cast<VkCuFunctionNVX>( m_function ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
6470  }
6471  m_device = nullptr;
6472  m_function = nullptr;
6473  m_allocator = nullptr;
6474  m_dispatcher = nullptr;
6475  }
6476 
6477  VULKAN_HPP_NAMESPACE::CuFunctionNVX release()
6478  {
6479  m_device = nullptr;
6480  m_allocator = nullptr;
6481  m_dispatcher = nullptr;
6482  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_function, nullptr );
6483  }
6484 
6485  VULKAN_HPP_NAMESPACE::Device getDevice() const
6486  {
6487  return m_device;
6488  }
6489 
6490  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
6491  {
6492  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
6493  return m_dispatcher;
6494  }
6495 
6496  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CuFunctionNVX & rhs ) VULKAN_HPP_NOEXCEPT
6497  {
6498  std::swap( m_device, rhs.m_device );
6499  std::swap( m_function, rhs.m_function );
6500  std::swap( m_allocator, rhs.m_allocator );
6501  std::swap( m_dispatcher, rhs.m_dispatcher );
6502  }
6503 
6504  private:
6505  VULKAN_HPP_NAMESPACE::Device m_device = {};
6506  VULKAN_HPP_NAMESPACE::CuFunctionNVX m_function = {};
6507  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
6508  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
6509  };
6510 
6512  {
6513  public:
6516 
6517  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCuModuleNVX;
6519  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCuModuleNVX;
6520 
6521  public:
6522 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
6523  CuModuleNVX( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
6524  VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX const & createInfo,
6525  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
6526  {
6527  *this = device.createCuModuleNVX( createInfo, allocator );
6528  }
6529 # endif
6530 
6531  CuModuleNVX( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
6533  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
6534  : m_device( device )
6535  , m_module( module )
6536  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
6537  , m_dispatcher( device.getDispatcher() )
6538  {
6539  }
6540 
6541  CuModuleNVX( std::nullptr_t ) {}
6542 
6544  {
6545  clear();
6546  }
6547 
6548  CuModuleNVX() = delete;
6549  CuModuleNVX( CuModuleNVX const & ) = delete;
6550 
6552  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
6553  , m_module( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_module, {} ) )
6554  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
6555  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
6556  {
6557  }
6558 
6559  CuModuleNVX & operator=( CuModuleNVX const & ) = delete;
6560 
6562  {
6563  if ( this != &rhs )
6564  {
6565  std::swap( m_device, rhs.m_device );
6566  std::swap( m_module, rhs.m_module );
6567  std::swap( m_allocator, rhs.m_allocator );
6568  std::swap( m_dispatcher, rhs.m_dispatcher );
6569  }
6570  return *this;
6571  }
6572 
6573  VULKAN_HPP_NAMESPACE::CuModuleNVX const & operator*() const VULKAN_HPP_NOEXCEPT
6574  {
6575  return m_module;
6576  }
6577 
6578  operator VULKAN_HPP_NAMESPACE::CuModuleNVX() const VULKAN_HPP_NOEXCEPT
6579  {
6580  return m_module;
6581  }
6582 
6584  {
6585  if ( m_module )
6586  {
6587  getDispatcher()->vkDestroyCuModuleNVX(
6588  static_cast<VkDevice>( m_device ), static_cast<VkCuModuleNVX>( m_module ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
6589  }
6590  m_device = nullptr;
6591  m_module = nullptr;
6592  m_allocator = nullptr;
6593  m_dispatcher = nullptr;
6594  }
6595 
6596  VULKAN_HPP_NAMESPACE::CuModuleNVX release()
6597  {
6598  m_device = nullptr;
6599  m_allocator = nullptr;
6600  m_dispatcher = nullptr;
6602  }
6603 
6604  VULKAN_HPP_NAMESPACE::Device getDevice() const
6605  {
6606  return m_device;
6607  }
6608 
6609  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
6610  {
6611  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
6612  return m_dispatcher;
6613  }
6614 
6615  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CuModuleNVX & rhs ) VULKAN_HPP_NOEXCEPT
6616  {
6617  std::swap( m_device, rhs.m_device );
6618  std::swap( m_module, rhs.m_module );
6619  std::swap( m_allocator, rhs.m_allocator );
6620  std::swap( m_dispatcher, rhs.m_dispatcher );
6621  }
6622 
6623  private:
6624  VULKAN_HPP_NAMESPACE::Device m_device = {};
6625  VULKAN_HPP_NAMESPACE::CuModuleNVX m_module = {};
6626  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
6627  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
6628  };
6629 
6630 # if defined( VK_ENABLE_BETA_EXTENSIONS )
6632  {
6633  public:
6636 
6637  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCudaFunctionNV;
6639  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCudaFunctionNV;
6640 
6641  public:
6642 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
6643  CudaFunctionNV( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
6644  VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV const & createInfo,
6645  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
6646  {
6647  *this = device.createCudaFunctionNV( createInfo, allocator );
6648  }
6649 # endif
6650 
6651  CudaFunctionNV( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
6652  VkCudaFunctionNV function,
6653  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
6654  : m_device( device )
6655  , m_function( function )
6656  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
6657  , m_dispatcher( device.getDispatcher() )
6658  {
6659  }
6660 
6661  CudaFunctionNV( std::nullptr_t ) {}
6662 
6664  {
6665  clear();
6666  }
6667 
6668  CudaFunctionNV() = delete;
6669  CudaFunctionNV( CudaFunctionNV const & ) = delete;
6670 
6672  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
6673  , m_function( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_function, {} ) )
6674  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
6675  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
6676  {
6677  }
6678 
6679  CudaFunctionNV & operator=( CudaFunctionNV const & ) = delete;
6680 
6682  {
6683  if ( this != &rhs )
6684  {
6685  std::swap( m_device, rhs.m_device );
6686  std::swap( m_function, rhs.m_function );
6687  std::swap( m_allocator, rhs.m_allocator );
6688  std::swap( m_dispatcher, rhs.m_dispatcher );
6689  }
6690  return *this;
6691  }
6692 
6693  VULKAN_HPP_NAMESPACE::CudaFunctionNV const & operator*() const VULKAN_HPP_NOEXCEPT
6694  {
6695  return m_function;
6696  }
6697 
6698  operator VULKAN_HPP_NAMESPACE::CudaFunctionNV() const VULKAN_HPP_NOEXCEPT
6699  {
6700  return m_function;
6701  }
6702 
6704  {
6705  if ( m_function )
6706  {
6707  getDispatcher()->vkDestroyCudaFunctionNV(
6708  static_cast<VkDevice>( m_device ), static_cast<VkCudaFunctionNV>( m_function ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
6709  }
6710  m_device = nullptr;
6711  m_function = nullptr;
6712  m_allocator = nullptr;
6713  m_dispatcher = nullptr;
6714  }
6715 
6716  VULKAN_HPP_NAMESPACE::CudaFunctionNV release()
6717  {
6718  m_device = nullptr;
6719  m_allocator = nullptr;
6720  m_dispatcher = nullptr;
6721  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_function, nullptr );
6722  }
6723 
6724  VULKAN_HPP_NAMESPACE::Device getDevice() const
6725  {
6726  return m_device;
6727  }
6728 
6729  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
6730  {
6731  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
6732  return m_dispatcher;
6733  }
6734 
6735  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CudaFunctionNV & rhs ) VULKAN_HPP_NOEXCEPT
6736  {
6737  std::swap( m_device, rhs.m_device );
6738  std::swap( m_function, rhs.m_function );
6739  std::swap( m_allocator, rhs.m_allocator );
6740  std::swap( m_dispatcher, rhs.m_dispatcher );
6741  }
6742 
6743  private:
6744  VULKAN_HPP_NAMESPACE::Device m_device = {};
6745  VULKAN_HPP_NAMESPACE::CudaFunctionNV m_function = {};
6746  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
6747  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
6748  };
6749 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
6750 
6751 # if defined( VK_ENABLE_BETA_EXTENSIONS )
6753  {
6754  public:
6757 
6758  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eCudaModuleNV;
6760  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eCudaModuleNV;
6761 
6762  public:
6763 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
6764  CudaModuleNV( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
6765  VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV const & createInfo,
6766  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
6767  {
6768  *this = device.createCudaModuleNV( createInfo, allocator );
6769  }
6770 # endif
6771 
6772  CudaModuleNV( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
6774  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
6775  : m_device( device )
6776  , m_module( module )
6777  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
6778  , m_dispatcher( device.getDispatcher() )
6779  {
6780  }
6781 
6782  CudaModuleNV( std::nullptr_t ) {}
6783 
6785  {
6786  clear();
6787  }
6788 
6789  CudaModuleNV() = delete;
6790  CudaModuleNV( CudaModuleNV const & ) = delete;
6791 
6793  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
6794  , m_module( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_module, {} ) )
6795  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
6796  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
6797  {
6798  }
6799 
6800  CudaModuleNV & operator=( CudaModuleNV const & ) = delete;
6801 
6803  {
6804  if ( this != &rhs )
6805  {
6806  std::swap( m_device, rhs.m_device );
6807  std::swap( m_module, rhs.m_module );
6808  std::swap( m_allocator, rhs.m_allocator );
6809  std::swap( m_dispatcher, rhs.m_dispatcher );
6810  }
6811  return *this;
6812  }
6813 
6814  VULKAN_HPP_NAMESPACE::CudaModuleNV const & operator*() const VULKAN_HPP_NOEXCEPT
6815  {
6816  return m_module;
6817  }
6818 
6819  operator VULKAN_HPP_NAMESPACE::CudaModuleNV() const VULKAN_HPP_NOEXCEPT
6820  {
6821  return m_module;
6822  }
6823 
6825  {
6826  if ( m_module )
6827  {
6828  getDispatcher()->vkDestroyCudaModuleNV(
6829  static_cast<VkDevice>( m_device ), static_cast<VkCudaModuleNV>( m_module ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
6830  }
6831  m_device = nullptr;
6832  m_module = nullptr;
6833  m_allocator = nullptr;
6834  m_dispatcher = nullptr;
6835  }
6836 
6837  VULKAN_HPP_NAMESPACE::CudaModuleNV release()
6838  {
6839  m_device = nullptr;
6840  m_allocator = nullptr;
6841  m_dispatcher = nullptr;
6843  }
6844 
6845  VULKAN_HPP_NAMESPACE::Device getDevice() const
6846  {
6847  return m_device;
6848  }
6849 
6850  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
6851  {
6852  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
6853  return m_dispatcher;
6854  }
6855 
6856  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CudaModuleNV & rhs ) VULKAN_HPP_NOEXCEPT
6857  {
6858  std::swap( m_device, rhs.m_device );
6859  std::swap( m_module, rhs.m_module );
6860  std::swap( m_allocator, rhs.m_allocator );
6861  std::swap( m_dispatcher, rhs.m_dispatcher );
6862  }
6863 
6864  //=== VK_NV_cuda_kernel_launch ===
6865 
6866  VULKAN_HPP_NODISCARD std::vector<uint8_t> getCache() const;
6867 
6868  private:
6869  VULKAN_HPP_NAMESPACE::Device m_device = {};
6870  VULKAN_HPP_NAMESPACE::CudaModuleNV m_module = {};
6871  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
6872  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
6873  };
6874 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
6875 
6877  {
6878  public:
6881 
6882  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDebugReportCallbackEXT;
6884  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDebugReportCallbackEXT;
6885 
6886  public:
6887 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
6888  DebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,
6889  VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT const & createInfo,
6890  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
6891  {
6892  *this = instance.createDebugReportCallbackEXT( createInfo, allocator );
6893  }
6894 # endif
6895 
6896  DebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,
6897  VkDebugReportCallbackEXT callback,
6898  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
6899  : m_instance( instance )
6900  , m_callback( callback )
6901  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
6902  , m_dispatcher( instance.getDispatcher() )
6903  {
6904  }
6905 
6906  DebugReportCallbackEXT( std::nullptr_t ) {}
6907 
6909  {
6910  clear();
6911  }
6912 
6915 
6917  : m_instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} ) )
6918  , m_callback( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_callback, {} ) )
6919  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
6920  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
6921  {
6922  }
6923 
6925 
6927  {
6928  if ( this != &rhs )
6929  {
6930  std::swap( m_instance, rhs.m_instance );
6931  std::swap( m_callback, rhs.m_callback );
6932  std::swap( m_allocator, rhs.m_allocator );
6933  std::swap( m_dispatcher, rhs.m_dispatcher );
6934  }
6935  return *this;
6936  }
6937 
6938  VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT const & operator*() const VULKAN_HPP_NOEXCEPT
6939  {
6940  return m_callback;
6941  }
6942 
6943  operator VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT() const VULKAN_HPP_NOEXCEPT
6944  {
6945  return m_callback;
6946  }
6947 
6949  {
6950  if ( m_callback )
6951  {
6952  getDispatcher()->vkDestroyDebugReportCallbackEXT( static_cast<VkInstance>( m_instance ),
6953  static_cast<VkDebugReportCallbackEXT>( m_callback ),
6954  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
6955  }
6956  m_instance = nullptr;
6957  m_callback = nullptr;
6958  m_allocator = nullptr;
6959  m_dispatcher = nullptr;
6960  }
6961 
6962  VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT release()
6963  {
6964  m_instance = nullptr;
6965  m_allocator = nullptr;
6966  m_dispatcher = nullptr;
6967  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_callback, nullptr );
6968  }
6969 
6970  VULKAN_HPP_NAMESPACE::Instance getInstance() const
6971  {
6972  return m_instance;
6973  }
6974 
6975  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const
6976  {
6977  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
6978  return m_dispatcher;
6979  }
6980 
6981  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DebugReportCallbackEXT & rhs ) VULKAN_HPP_NOEXCEPT
6982  {
6983  std::swap( m_instance, rhs.m_instance );
6984  std::swap( m_callback, rhs.m_callback );
6985  std::swap( m_allocator, rhs.m_allocator );
6986  std::swap( m_dispatcher, rhs.m_dispatcher );
6987  }
6988 
6989  private:
6990  VULKAN_HPP_NAMESPACE::Instance m_instance = {};
6991  VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT m_callback = {};
6992  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
6993  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr;
6994  };
6995 
6997  {
6998  public:
7001 
7002  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDebugUtilsMessengerEXT;
7004  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
7005 
7006  public:
7007 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
7008  DebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,
7009  VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT const & createInfo,
7010  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
7011  {
7012  *this = instance.createDebugUtilsMessengerEXT( createInfo, allocator );
7013  }
7014 # endif
7015 
7016  DebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,
7017  VkDebugUtilsMessengerEXT messenger,
7018  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
7019  : m_instance( instance )
7020  , m_messenger( messenger )
7021  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
7022  , m_dispatcher( instance.getDispatcher() )
7023  {
7024  }
7025 
7026  DebugUtilsMessengerEXT( std::nullptr_t ) {}
7027 
7029  {
7030  clear();
7031  }
7032 
7035 
7037  : m_instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} ) )
7038  , m_messenger( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_messenger, {} ) )
7039  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
7040  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
7041  {
7042  }
7043 
7045 
7047  {
7048  if ( this != &rhs )
7049  {
7050  std::swap( m_instance, rhs.m_instance );
7051  std::swap( m_messenger, rhs.m_messenger );
7052  std::swap( m_allocator, rhs.m_allocator );
7053  std::swap( m_dispatcher, rhs.m_dispatcher );
7054  }
7055  return *this;
7056  }
7057 
7058  VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT const & operator*() const VULKAN_HPP_NOEXCEPT
7059  {
7060  return m_messenger;
7061  }
7062 
7063  operator VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT() const VULKAN_HPP_NOEXCEPT
7064  {
7065  return m_messenger;
7066  }
7067 
7069  {
7070  if ( m_messenger )
7071  {
7072  getDispatcher()->vkDestroyDebugUtilsMessengerEXT( static_cast<VkInstance>( m_instance ),
7073  static_cast<VkDebugUtilsMessengerEXT>( m_messenger ),
7074  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
7075  }
7076  m_instance = nullptr;
7077  m_messenger = nullptr;
7078  m_allocator = nullptr;
7079  m_dispatcher = nullptr;
7080  }
7081 
7082  VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT release()
7083  {
7084  m_instance = nullptr;
7085  m_allocator = nullptr;
7086  m_dispatcher = nullptr;
7087  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_messenger, nullptr );
7088  }
7089 
7090  VULKAN_HPP_NAMESPACE::Instance getInstance() const
7091  {
7092  return m_instance;
7093  }
7094 
7095  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const
7096  {
7097  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
7098  return m_dispatcher;
7099  }
7100 
7101  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DebugUtilsMessengerEXT & rhs ) VULKAN_HPP_NOEXCEPT
7102  {
7103  std::swap( m_instance, rhs.m_instance );
7104  std::swap( m_messenger, rhs.m_messenger );
7105  std::swap( m_allocator, rhs.m_allocator );
7106  std::swap( m_dispatcher, rhs.m_dispatcher );
7107  }
7108 
7109  private:
7110  VULKAN_HPP_NAMESPACE::Instance m_instance = {};
7111  VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT m_messenger = {};
7112  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
7113  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr;
7114  };
7115 
7117  {
7118  public:
7121 
7122  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDeferredOperationKHR;
7124  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
7125 
7126  public:
7127 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
7128  DeferredOperationKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
7129  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
7130  {
7131  *this = device.createDeferredOperationKHR( allocator );
7132  }
7133 # endif
7134 
7135  DeferredOperationKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
7136  VkDeferredOperationKHR operation,
7137  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
7138  : m_device( device )
7139  , m_operation( operation )
7140  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
7141  , m_dispatcher( device.getDispatcher() )
7142  {
7143  }
7144 
7145  DeferredOperationKHR( std::nullptr_t ) {}
7146 
7148  {
7149  clear();
7150  }
7151 
7154 
7156  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
7157  , m_operation( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_operation, {} ) )
7158  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
7159  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
7160  {
7161  }
7162 
7164 
7166  {
7167  if ( this != &rhs )
7168  {
7169  std::swap( m_device, rhs.m_device );
7170  std::swap( m_operation, rhs.m_operation );
7171  std::swap( m_allocator, rhs.m_allocator );
7172  std::swap( m_dispatcher, rhs.m_dispatcher );
7173  }
7174  return *this;
7175  }
7176 
7177  VULKAN_HPP_NAMESPACE::DeferredOperationKHR const & operator*() const VULKAN_HPP_NOEXCEPT
7178  {
7179  return m_operation;
7180  }
7181 
7182  operator VULKAN_HPP_NAMESPACE::DeferredOperationKHR() const VULKAN_HPP_NOEXCEPT
7183  {
7184  return m_operation;
7185  }
7186 
7188  {
7189  if ( m_operation )
7190  {
7191  getDispatcher()->vkDestroyDeferredOperationKHR( static_cast<VkDevice>( m_device ),
7192  static_cast<VkDeferredOperationKHR>( m_operation ),
7193  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
7194  }
7195  m_device = nullptr;
7196  m_operation = nullptr;
7197  m_allocator = nullptr;
7198  m_dispatcher = nullptr;
7199  }
7200 
7201  VULKAN_HPP_NAMESPACE::DeferredOperationKHR release()
7202  {
7203  m_device = nullptr;
7204  m_allocator = nullptr;
7205  m_dispatcher = nullptr;
7206  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_operation, nullptr );
7207  }
7208 
7209  VULKAN_HPP_NAMESPACE::Device getDevice() const
7210  {
7211  return m_device;
7212  }
7213 
7214  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
7215  {
7216  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
7217  return m_dispatcher;
7218  }
7219 
7220  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR & rhs ) VULKAN_HPP_NOEXCEPT
7221  {
7222  std::swap( m_device, rhs.m_device );
7223  std::swap( m_operation, rhs.m_operation );
7224  std::swap( m_allocator, rhs.m_allocator );
7225  std::swap( m_dispatcher, rhs.m_dispatcher );
7226  }
7227 
7228  //=== VK_KHR_deferred_host_operations ===
7229 
7230  VULKAN_HPP_NODISCARD uint32_t getMaxConcurrency() const VULKAN_HPP_NOEXCEPT;
7231 
7232  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result getResult() const VULKAN_HPP_NOEXCEPT;
7233 
7234  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result join() const;
7235 
7236  private:
7237  VULKAN_HPP_NAMESPACE::Device m_device = {};
7238  VULKAN_HPP_NAMESPACE::DeferredOperationKHR m_operation = {};
7239  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
7240  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
7241  };
7242 
7244  {
7245  public:
7248 
7249  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorPool;
7251  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorPool;
7252 
7253  public:
7254 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
7255  DescriptorPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
7256  VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo const & createInfo,
7257  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
7258  {
7259  *this = device.createDescriptorPool( createInfo, allocator );
7260  }
7261 # endif
7262 
7263  DescriptorPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
7264  VkDescriptorPool descriptorPool,
7265  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
7266  : m_device( device )
7267  , m_descriptorPool( descriptorPool )
7268  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
7269  , m_dispatcher( device.getDispatcher() )
7270  {
7271  }
7272 
7273  DescriptorPool( std::nullptr_t ) {}
7274 
7276  {
7277  clear();
7278  }
7279 
7280  DescriptorPool() = delete;
7281  DescriptorPool( DescriptorPool const & ) = delete;
7282 
7284  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
7285  , m_descriptorPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorPool, {} ) )
7286  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
7287  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
7288  {
7289  }
7290 
7291  DescriptorPool & operator=( DescriptorPool const & ) = delete;
7292 
7294  {
7295  if ( this != &rhs )
7296  {
7297  std::swap( m_device, rhs.m_device );
7298  std::swap( m_descriptorPool, rhs.m_descriptorPool );
7299  std::swap( m_allocator, rhs.m_allocator );
7300  std::swap( m_dispatcher, rhs.m_dispatcher );
7301  }
7302  return *this;
7303  }
7304 
7305  VULKAN_HPP_NAMESPACE::DescriptorPool const & operator*() const VULKAN_HPP_NOEXCEPT
7306  {
7307  return m_descriptorPool;
7308  }
7309 
7310  operator VULKAN_HPP_NAMESPACE::DescriptorPool() const VULKAN_HPP_NOEXCEPT
7311  {
7312  return m_descriptorPool;
7313  }
7314 
7316  {
7317  if ( m_descriptorPool )
7318  {
7319  getDispatcher()->vkDestroyDescriptorPool( static_cast<VkDevice>( m_device ),
7320  static_cast<VkDescriptorPool>( m_descriptorPool ),
7321  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
7322  }
7323  m_device = nullptr;
7324  m_descriptorPool = nullptr;
7325  m_allocator = nullptr;
7326  m_dispatcher = nullptr;
7327  }
7328 
7329  VULKAN_HPP_NAMESPACE::DescriptorPool release()
7330  {
7331  m_device = nullptr;
7332  m_allocator = nullptr;
7333  m_dispatcher = nullptr;
7334  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_descriptorPool, nullptr );
7335  }
7336 
7337  VULKAN_HPP_NAMESPACE::Device getDevice() const
7338  {
7339  return m_device;
7340  }
7341 
7342  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
7343  {
7344  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
7345  return m_dispatcher;
7346  }
7347 
7348  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorPool & rhs ) VULKAN_HPP_NOEXCEPT
7349  {
7350  std::swap( m_device, rhs.m_device );
7351  std::swap( m_descriptorPool, rhs.m_descriptorPool );
7352  std::swap( m_allocator, rhs.m_allocator );
7353  std::swap( m_dispatcher, rhs.m_dispatcher );
7354  }
7355 
7356  //=== VK_VERSION_1_0 ===
7357 
7359 
7360  private:
7361  VULKAN_HPP_NAMESPACE::Device m_device = {};
7362  VULKAN_HPP_NAMESPACE::DescriptorPool m_descriptorPool = {};
7363  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
7364  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
7365  };
7366 
7368  {
7369  public:
7372 
7373  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSet;
7375  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSet;
7376 
7377  public:
7378  DescriptorSet( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkDescriptorSet descriptorSet, VkDescriptorPool descriptorPool )
7379  : m_device( device ), m_descriptorPool( descriptorPool ), m_descriptorSet( descriptorSet ), m_dispatcher( device.getDispatcher() )
7380  {
7381  }
7382 
7383  DescriptorSet( std::nullptr_t ) {}
7384 
7386  {
7387  clear();
7388  }
7389 
7390  DescriptorSet() = delete;
7391  DescriptorSet( DescriptorSet const & ) = delete;
7392 
7394  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
7395  , m_descriptorPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorPool, {} ) )
7396  , m_descriptorSet( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorSet, {} ) )
7397  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
7398  {
7399  }
7400 
7401  DescriptorSet & operator=( DescriptorSet const & ) = delete;
7402 
7404  {
7405  if ( this != &rhs )
7406  {
7407  std::swap( m_device, rhs.m_device );
7408  std::swap( m_descriptorPool, rhs.m_descriptorPool );
7409  std::swap( m_descriptorSet, rhs.m_descriptorSet );
7410  std::swap( m_dispatcher, rhs.m_dispatcher );
7411  }
7412  return *this;
7413  }
7414 
7415  VULKAN_HPP_NAMESPACE::DescriptorSet const & operator*() const VULKAN_HPP_NOEXCEPT
7416  {
7417  return m_descriptorSet;
7418  }
7419 
7420  operator VULKAN_HPP_NAMESPACE::DescriptorSet() const VULKAN_HPP_NOEXCEPT
7421  {
7422  return m_descriptorSet;
7423  }
7424 
7426  {
7427  if ( m_descriptorSet )
7428  {
7429  getDispatcher()->vkFreeDescriptorSets( static_cast<VkDevice>( m_device ),
7430  static_cast<VkDescriptorPool>( m_descriptorPool ),
7431  1,
7432  reinterpret_cast<VkDescriptorSet const *>( &m_descriptorSet ) );
7433  }
7434  m_device = nullptr;
7435  m_descriptorPool = nullptr;
7436  m_descriptorSet = nullptr;
7437  m_dispatcher = nullptr;
7438  }
7439 
7440  VULKAN_HPP_NAMESPACE::DescriptorSet release()
7441  {
7442  m_device = nullptr;
7443  m_descriptorPool = nullptr;
7444  m_dispatcher = nullptr;
7445  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_descriptorSet, nullptr );
7446  }
7447 
7448  VULKAN_HPP_NAMESPACE::Device getDevice() const
7449  {
7450  return m_device;
7451  }
7452 
7453  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
7454  {
7455  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
7456  return m_dispatcher;
7457  }
7458 
7459  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSet & rhs ) VULKAN_HPP_NOEXCEPT
7460  {
7461  std::swap( m_device, rhs.m_device );
7462  std::swap( m_descriptorPool, rhs.m_descriptorPool );
7463  std::swap( m_descriptorSet, rhs.m_descriptorSet );
7464  std::swap( m_dispatcher, rhs.m_dispatcher );
7465  }
7466 
7467  //=== VK_VERSION_1_1 ===
7468 
7469  template <typename DataType>
7470  void updateWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, DataType const & data ) const VULKAN_HPP_NOEXCEPT;
7471 
7472  //=== VK_KHR_descriptor_update_template ===
7473 
7474  template <typename DataType>
7475  void updateWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, DataType const & data ) const VULKAN_HPP_NOEXCEPT;
7476 
7477  //=== VK_VALVE_descriptor_set_host_mapping ===
7478 
7479  VULKAN_HPP_NODISCARD void * getHostMappingVALVE() const VULKAN_HPP_NOEXCEPT;
7480 
7481  private:
7482  VULKAN_HPP_NAMESPACE::Device m_device = {};
7483  VULKAN_HPP_NAMESPACE::DescriptorPool m_descriptorPool = {};
7484  VULKAN_HPP_NAMESPACE::DescriptorSet m_descriptorSet = {};
7485  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
7486  };
7487 
7488  class DescriptorSets : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSet>
7489  {
7490  public:
7491 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
7492  DescriptorSets( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
7493  VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo const & allocateInfo )
7494  {
7495  *this = device.allocateDescriptorSets( allocateInfo );
7496  }
7497 # endif
7498 
7499  DescriptorSets( std::nullptr_t ) {}
7500 
7501  DescriptorSets() = delete;
7502  DescriptorSets( DescriptorSets const & ) = delete;
7503  DescriptorSets( DescriptorSets && rhs ) = default;
7504  DescriptorSets & operator=( DescriptorSets const & ) = delete;
7505  DescriptorSets & operator=( DescriptorSets && rhs ) = default;
7506 
7507  private:
7508  DescriptorSets( std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSet> && rhs )
7509  {
7510  std::swap( *this, rhs );
7511  }
7512  };
7513 
7515  {
7516  public:
7519 
7520  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorSetLayout;
7522  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorSetLayout;
7523 
7524  public:
7525 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
7526  DescriptorSetLayout( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
7527  VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo const & createInfo,
7528  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
7529  {
7530  *this = device.createDescriptorSetLayout( createInfo, allocator );
7531  }
7532 # endif
7533 
7534  DescriptorSetLayout( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
7535  VkDescriptorSetLayout descriptorSetLayout,
7536  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
7537  : m_device( device )
7538  , m_descriptorSetLayout( descriptorSetLayout )
7539  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
7540  , m_dispatcher( device.getDispatcher() )
7541  {
7542  }
7543 
7544  DescriptorSetLayout( std::nullptr_t ) {}
7545 
7547  {
7548  clear();
7549  }
7550 
7553 
7555  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
7556  , m_descriptorSetLayout( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorSetLayout, {} ) )
7557  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
7558  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
7559  {
7560  }
7561 
7563 
7565  {
7566  if ( this != &rhs )
7567  {
7568  std::swap( m_device, rhs.m_device );
7569  std::swap( m_descriptorSetLayout, rhs.m_descriptorSetLayout );
7570  std::swap( m_allocator, rhs.m_allocator );
7571  std::swap( m_dispatcher, rhs.m_dispatcher );
7572  }
7573  return *this;
7574  }
7575 
7576  VULKAN_HPP_NAMESPACE::DescriptorSetLayout const & operator*() const VULKAN_HPP_NOEXCEPT
7577  {
7578  return m_descriptorSetLayout;
7579  }
7580 
7581  operator VULKAN_HPP_NAMESPACE::DescriptorSetLayout() const VULKAN_HPP_NOEXCEPT
7582  {
7583  return m_descriptorSetLayout;
7584  }
7585 
7587  {
7588  if ( m_descriptorSetLayout )
7589  {
7590  getDispatcher()->vkDestroyDescriptorSetLayout( static_cast<VkDevice>( m_device ),
7591  static_cast<VkDescriptorSetLayout>( m_descriptorSetLayout ),
7592  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
7593  }
7594  m_device = nullptr;
7595  m_descriptorSetLayout = nullptr;
7596  m_allocator = nullptr;
7597  m_dispatcher = nullptr;
7598  }
7599 
7600  VULKAN_HPP_NAMESPACE::DescriptorSetLayout release()
7601  {
7602  m_device = nullptr;
7603  m_allocator = nullptr;
7604  m_dispatcher = nullptr;
7605  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_descriptorSetLayout, nullptr );
7606  }
7607 
7608  VULKAN_HPP_NAMESPACE::Device getDevice() const
7609  {
7610  return m_device;
7611  }
7612 
7613  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
7614  {
7615  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
7616  return m_dispatcher;
7617  }
7618 
7619  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSetLayout & rhs ) VULKAN_HPP_NOEXCEPT
7620  {
7621  std::swap( m_device, rhs.m_device );
7622  std::swap( m_descriptorSetLayout, rhs.m_descriptorSetLayout );
7623  std::swap( m_allocator, rhs.m_allocator );
7624  std::swap( m_dispatcher, rhs.m_dispatcher );
7625  }
7626 
7627  //=== VK_EXT_descriptor_buffer ===
7628 
7630 
7631  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize getBindingOffsetEXT( uint32_t binding ) const VULKAN_HPP_NOEXCEPT;
7632 
7633  private:
7634  VULKAN_HPP_NAMESPACE::Device m_device = {};
7635  VULKAN_HPP_NAMESPACE::DescriptorSetLayout m_descriptorSetLayout = {};
7636  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
7637  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
7638  };
7639 
7641  {
7642  public:
7645 
7646  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDescriptorUpdateTemplate;
7648  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDescriptorUpdateTemplate;
7649 
7650  public:
7651 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
7652  DescriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
7653  VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & createInfo,
7654  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
7655  {
7656  *this = device.createDescriptorUpdateTemplate( createInfo, allocator );
7657  }
7658 # endif
7659 
7660  DescriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
7661  VkDescriptorUpdateTemplate descriptorUpdateTemplate,
7662  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
7663  : m_device( device )
7664  , m_descriptorUpdateTemplate( descriptorUpdateTemplate )
7665  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
7666  , m_dispatcher( device.getDispatcher() )
7667  {
7668  }
7669 
7670  DescriptorUpdateTemplate( std::nullptr_t ) {}
7671 
7673  {
7674  clear();
7675  }
7676 
7679 
7681  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
7682  , m_descriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_descriptorUpdateTemplate, {} ) )
7683  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
7684  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
7685  {
7686  }
7687 
7689 
7691  {
7692  if ( this != &rhs )
7693  {
7694  std::swap( m_device, rhs.m_device );
7695  std::swap( m_descriptorUpdateTemplate, rhs.m_descriptorUpdateTemplate );
7696  std::swap( m_allocator, rhs.m_allocator );
7697  std::swap( m_dispatcher, rhs.m_dispatcher );
7698  }
7699  return *this;
7700  }
7701 
7702  VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate const & operator*() const VULKAN_HPP_NOEXCEPT
7703  {
7704  return m_descriptorUpdateTemplate;
7705  }
7706 
7707  operator VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate() const VULKAN_HPP_NOEXCEPT
7708  {
7709  return m_descriptorUpdateTemplate;
7710  }
7711 
7713  {
7714  if ( m_descriptorUpdateTemplate )
7715  {
7716  getDispatcher()->vkDestroyDescriptorUpdateTemplate( static_cast<VkDevice>( m_device ),
7717  static_cast<VkDescriptorUpdateTemplate>( m_descriptorUpdateTemplate ),
7718  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
7719  }
7720  m_device = nullptr;
7721  m_descriptorUpdateTemplate = nullptr;
7722  m_allocator = nullptr;
7723  m_dispatcher = nullptr;
7724  }
7725 
7726  VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate release()
7727  {
7728  m_device = nullptr;
7729  m_allocator = nullptr;
7730  m_dispatcher = nullptr;
7731  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_descriptorUpdateTemplate, nullptr );
7732  }
7733 
7734  VULKAN_HPP_NAMESPACE::Device getDevice() const
7735  {
7736  return m_device;
7737  }
7738 
7739  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
7740  {
7741  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
7742  return m_dispatcher;
7743  }
7744 
7745  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate & rhs ) VULKAN_HPP_NOEXCEPT
7746  {
7747  std::swap( m_device, rhs.m_device );
7748  std::swap( m_descriptorUpdateTemplate, rhs.m_descriptorUpdateTemplate );
7749  std::swap( m_allocator, rhs.m_allocator );
7750  std::swap( m_dispatcher, rhs.m_dispatcher );
7751  }
7752 
7753  private:
7754  VULKAN_HPP_NAMESPACE::Device m_device = {};
7755  VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate m_descriptorUpdateTemplate = {};
7756  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
7757  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
7758  };
7759 
7761  {
7762  public:
7765 
7766  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDeviceMemory;
7768  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDeviceMemory;
7769 
7770  public:
7771 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
7772  DeviceMemory( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
7773  VULKAN_HPP_NAMESPACE::MemoryAllocateInfo const & allocateInfo,
7774  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
7775  {
7776  *this = device.allocateMemory( allocateInfo, allocator );
7777  }
7778 # endif
7779 
7780  DeviceMemory( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
7781  VkDeviceMemory memory,
7782  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
7783  : m_device( device )
7784  , m_memory( memory )
7785  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
7786  , m_dispatcher( device.getDispatcher() )
7787  {
7788  }
7789 
7790  DeviceMemory( std::nullptr_t ) {}
7791 
7793  {
7794  clear();
7795  }
7796 
7797  DeviceMemory() = delete;
7798  DeviceMemory( DeviceMemory const & ) = delete;
7799 
7801  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
7802  , m_memory( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_memory, {} ) )
7803  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
7804  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
7805  {
7806  }
7807 
7808  DeviceMemory & operator=( DeviceMemory const & ) = delete;
7809 
7811  {
7812  if ( this != &rhs )
7813  {
7814  std::swap( m_device, rhs.m_device );
7815  std::swap( m_memory, rhs.m_memory );
7816  std::swap( m_allocator, rhs.m_allocator );
7817  std::swap( m_dispatcher, rhs.m_dispatcher );
7818  }
7819  return *this;
7820  }
7821 
7822  VULKAN_HPP_NAMESPACE::DeviceMemory const & operator*() const VULKAN_HPP_NOEXCEPT
7823  {
7824  return m_memory;
7825  }
7826 
7827  operator VULKAN_HPP_NAMESPACE::DeviceMemory() const VULKAN_HPP_NOEXCEPT
7828  {
7829  return m_memory;
7830  }
7831 
7833  {
7834  if ( m_memory )
7835  {
7836  getDispatcher()->vkFreeMemory(
7837  static_cast<VkDevice>( m_device ), static_cast<VkDeviceMemory>( m_memory ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
7838  }
7839  m_device = nullptr;
7840  m_memory = nullptr;
7841  m_allocator = nullptr;
7842  m_dispatcher = nullptr;
7843  }
7844 
7845  VULKAN_HPP_NAMESPACE::DeviceMemory release()
7846  {
7847  m_device = nullptr;
7848  m_allocator = nullptr;
7849  m_dispatcher = nullptr;
7851  }
7852 
7853  VULKAN_HPP_NAMESPACE::Device getDevice() const
7854  {
7855  return m_device;
7856  }
7857 
7858  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
7859  {
7860  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
7861  return m_dispatcher;
7862  }
7863 
7864  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceMemory & rhs ) VULKAN_HPP_NOEXCEPT
7865  {
7866  std::swap( m_device, rhs.m_device );
7867  std::swap( m_memory, rhs.m_memory );
7868  std::swap( m_allocator, rhs.m_allocator );
7869  std::swap( m_dispatcher, rhs.m_dispatcher );
7870  }
7871 
7872  //=== VK_VERSION_1_0 ===
7873 
7874  VULKAN_HPP_NODISCARD void * mapMemory( VULKAN_HPP_NAMESPACE::DeviceSize offset,
7877 
7878  void unmapMemory() const VULKAN_HPP_NOEXCEPT;
7879 
7880  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DeviceSize getCommitment() const VULKAN_HPP_NOEXCEPT;
7881 
7882 # if defined( VK_USE_PLATFORM_WIN32_KHR )
7883  //=== VK_NV_external_memory_win32 ===
7884 
7885  VULKAN_HPP_NODISCARD HANDLE getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType ) const;
7886 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
7887 
7888  //=== VK_EXT_pageable_device_local_memory ===
7889 
7890  void setPriorityEXT( float priority ) const VULKAN_HPP_NOEXCEPT;
7891 
7892  private:
7893  VULKAN_HPP_NAMESPACE::Device m_device = {};
7894  VULKAN_HPP_NAMESPACE::DeviceMemory m_memory = {};
7895  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
7896  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
7897  };
7898 
7900  {
7901  public:
7904 
7905  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDisplayKHR;
7907  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayKHR;
7908 
7909  public:
7910 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
7911  DisplayKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice, int32_t drmFd, uint32_t connectorId )
7912  {
7913  *this = physicalDevice.getDrmDisplayEXT( drmFd, connectorId );
7914  }
7915 # endif
7916 
7917 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
7918 # if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
7919  DisplayKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice, Display & dpy, RROutput rrOutput )
7920  {
7921  *this = physicalDevice.getRandROutputDisplayEXT( dpy, rrOutput );
7922  }
7923 # endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
7924 # endif
7925 
7926 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
7927 # if defined( VK_USE_PLATFORM_WIN32_KHR )
7928  DisplayKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice, uint32_t deviceRelativeId )
7929  {
7930  *this = physicalDevice.getWinrtDisplayNV( deviceRelativeId );
7931  }
7932 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
7933 # endif
7934 
7935  DisplayKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice, VkDisplayKHR display )
7936  : m_physicalDevice( physicalDevice ), m_display( display ), m_dispatcher( physicalDevice.getDispatcher() )
7937  {
7938  }
7939 
7940  DisplayKHR( std::nullptr_t ) {}
7941 
7943  {
7944  clear();
7945  }
7946 
7947  DisplayKHR() = delete;
7948  DisplayKHR( DisplayKHR const & ) = delete;
7949 
7951  : m_physicalDevice( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} ) )
7952  , m_display( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_display, {} ) )
7953  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
7954  {
7955  }
7956 
7957  DisplayKHR & operator=( DisplayKHR const & ) = delete;
7958 
7960  {
7961  if ( this != &rhs )
7962  {
7963  std::swap( m_physicalDevice, rhs.m_physicalDevice );
7964  std::swap( m_display, rhs.m_display );
7965  std::swap( m_dispatcher, rhs.m_dispatcher );
7966  }
7967  return *this;
7968  }
7969 
7970  VULKAN_HPP_NAMESPACE::DisplayKHR const & operator*() const VULKAN_HPP_NOEXCEPT
7971  {
7972  return m_display;
7973  }
7974 
7975  operator VULKAN_HPP_NAMESPACE::DisplayKHR() const VULKAN_HPP_NOEXCEPT
7976  {
7977  return m_display;
7978  }
7979 
7981  {
7982  if ( m_display )
7983  {
7984  getDispatcher()->vkReleaseDisplayEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkDisplayKHR>( m_display ) );
7985  }
7986  m_physicalDevice = nullptr;
7987  m_display = nullptr;
7988  m_dispatcher = nullptr;
7989  }
7990 
7991  VULKAN_HPP_NAMESPACE::DisplayKHR release()
7992  {
7993  m_physicalDevice = nullptr;
7994  m_dispatcher = nullptr;
7995  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_display, nullptr );
7996  }
7997 
7998  VULKAN_HPP_NAMESPACE::PhysicalDevice getPhysicalDevice() const
7999  {
8000  return m_physicalDevice;
8001  }
8002 
8003  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const
8004  {
8005  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
8006  return m_dispatcher;
8007  }
8008 
8009  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR & rhs ) VULKAN_HPP_NOEXCEPT
8010  {
8011  std::swap( m_physicalDevice, rhs.m_physicalDevice );
8012  std::swap( m_display, rhs.m_display );
8013  std::swap( m_dispatcher, rhs.m_dispatcher );
8014  }
8015 
8016  //=== VK_KHR_display ===
8017 
8018  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR> getModeProperties() const;
8019 
8021  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayModeKHR>::Type
8022  createMode( VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR const & createInfo,
8023  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT;
8024 
8025  //=== VK_KHR_get_display_properties2 ===
8026 
8027  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR> getModeProperties2() const;
8028 
8029 # if defined( VK_USE_PLATFORM_WIN32_KHR )
8030  //=== VK_NV_acquire_winrt_display ===
8031 
8032  void acquireWinrtNV() const;
8033 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
8034 
8035  private:
8036  VULKAN_HPP_NAMESPACE::PhysicalDevice m_physicalDevice = {};
8037  VULKAN_HPP_NAMESPACE::DisplayKHR m_display = {};
8038  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr;
8039  };
8040 
8041  class DisplayKHRs : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR>
8042  {
8043  public:
8044 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
8045  DisplayKHRs( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice, uint32_t planeIndex )
8046  {
8047  *this = physicalDevice.getDisplayPlaneSupportedDisplaysKHR( planeIndex );
8048  }
8049 # endif
8050 
8051  DisplayKHRs( std::nullptr_t ) {}
8052 
8053  DisplayKHRs() = delete;
8054  DisplayKHRs( DisplayKHRs const & ) = delete;
8055  DisplayKHRs( DisplayKHRs && rhs ) = default;
8056  DisplayKHRs & operator=( DisplayKHRs const & ) = delete;
8057  DisplayKHRs & operator=( DisplayKHRs && rhs ) = default;
8058 
8059  private:
8060  DisplayKHRs( std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR> && rhs )
8061  {
8062  std::swap( *this, rhs );
8063  }
8064  };
8065 
8067  {
8068  public:
8071 
8072  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eDisplayModeKHR;
8074  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eDisplayModeKHR;
8075 
8076  public:
8077 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
8078  DisplayModeKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const & display,
8079  VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR const & createInfo,
8080  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
8081  {
8082  *this = display.createMode( createInfo, allocator );
8083  }
8084 # endif
8085 
8086  DisplayModeKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const & display, VkDisplayModeKHR displayModeKHR )
8087  : m_physicalDevice( display.getPhysicalDevice() ), m_displayModeKHR( displayModeKHR ), m_dispatcher( display.getDispatcher() )
8088  {
8089  }
8090 
8091  DisplayModeKHR( std::nullptr_t ) {}
8092 
8094  {
8095  clear();
8096  }
8097 
8098  DisplayModeKHR() = delete;
8099 
8100  DisplayModeKHR( DisplayModeKHR const & rhs ) : m_displayModeKHR( rhs.m_displayModeKHR ), m_dispatcher( rhs.m_dispatcher ) {}
8101 
8103  : m_physicalDevice( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_physicalDevice, {} ) )
8104  , m_displayModeKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_displayModeKHR, {} ) )
8105  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
8106  {
8107  }
8108 
8110  {
8111  m_displayModeKHR = rhs.m_displayModeKHR;
8112  m_dispatcher = rhs.m_dispatcher;
8113  return *this;
8114  }
8115 
8117  {
8118  if ( this != &rhs )
8119  {
8120  std::swap( m_physicalDevice, rhs.m_physicalDevice );
8121  std::swap( m_displayModeKHR, rhs.m_displayModeKHR );
8122  std::swap( m_dispatcher, rhs.m_dispatcher );
8123  }
8124  return *this;
8125  }
8126 
8127  VULKAN_HPP_NAMESPACE::DisplayModeKHR const & operator*() const VULKAN_HPP_NOEXCEPT
8128  {
8129  return m_displayModeKHR;
8130  }
8131 
8132  operator VULKAN_HPP_NAMESPACE::DisplayModeKHR() const VULKAN_HPP_NOEXCEPT
8133  {
8134  return m_displayModeKHR;
8135  }
8136 
8138  {
8139  m_physicalDevice = nullptr;
8140  m_displayModeKHR = nullptr;
8141  m_dispatcher = nullptr;
8142  }
8143 
8144  VULKAN_HPP_NAMESPACE::DisplayModeKHR release()
8145  {
8146  m_physicalDevice = nullptr;
8147  m_dispatcher = nullptr;
8148  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_displayModeKHR, nullptr );
8149  }
8150 
8151  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const
8152  {
8153  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
8154  return m_dispatcher;
8155  }
8156 
8157  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayModeKHR & rhs ) VULKAN_HPP_NOEXCEPT
8158  {
8159  std::swap( m_physicalDevice, rhs.m_physicalDevice );
8160  std::swap( m_displayModeKHR, rhs.m_displayModeKHR );
8161  std::swap( m_dispatcher, rhs.m_dispatcher );
8162  }
8163 
8164  //=== VK_KHR_display ===
8165 
8166  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR getDisplayPlaneCapabilities( uint32_t planeIndex ) const;
8167 
8168  private:
8169  VULKAN_HPP_NAMESPACE::PhysicalDevice m_physicalDevice = {};
8170  VULKAN_HPP_NAMESPACE::DisplayModeKHR m_displayModeKHR = {};
8171  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr;
8172  };
8173 
8174  class Event
8175  {
8176  public:
8177  using CType = VkEvent;
8179 
8180  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eEvent;
8182  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eEvent;
8183 
8184  public:
8185 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
8186  Event( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
8187  VULKAN_HPP_NAMESPACE::EventCreateInfo const & createInfo,
8188  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
8189  {
8190  *this = device.createEvent( createInfo, allocator );
8191  }
8192 # endif
8193 
8194  Event( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
8195  VkEvent event,
8196  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
8197  : m_device( device )
8198  , m_event( event )
8199  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
8200  , m_dispatcher( device.getDispatcher() )
8201  {
8202  }
8203 
8204  Event( std::nullptr_t ) {}
8205 
8207  {
8208  clear();
8209  }
8210 
8211  Event() = delete;
8212  Event( Event const & ) = delete;
8213 
8215  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
8216  , m_event( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_event, {} ) )
8217  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
8218  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
8219  {
8220  }
8221 
8222  Event & operator=( Event const & ) = delete;
8223 
8225  {
8226  if ( this != &rhs )
8227  {
8228  std::swap( m_device, rhs.m_device );
8229  std::swap( m_event, rhs.m_event );
8230  std::swap( m_allocator, rhs.m_allocator );
8231  std::swap( m_dispatcher, rhs.m_dispatcher );
8232  }
8233  return *this;
8234  }
8235 
8236  VULKAN_HPP_NAMESPACE::Event const & operator*() const VULKAN_HPP_NOEXCEPT
8237  {
8238  return m_event;
8239  }
8240 
8241  operator VULKAN_HPP_NAMESPACE::Event() const VULKAN_HPP_NOEXCEPT
8242  {
8243  return m_event;
8244  }
8245 
8247  {
8248  if ( m_event )
8249  {
8250  getDispatcher()->vkDestroyEvent(
8251  static_cast<VkDevice>( m_device ), static_cast<VkEvent>( m_event ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
8252  }
8253  m_device = nullptr;
8254  m_event = nullptr;
8255  m_allocator = nullptr;
8256  m_dispatcher = nullptr;
8257  }
8258 
8259  VULKAN_HPP_NAMESPACE::Event release()
8260  {
8261  m_device = nullptr;
8262  m_allocator = nullptr;
8263  m_dispatcher = nullptr;
8265  }
8266 
8267  VULKAN_HPP_NAMESPACE::Device getDevice() const
8268  {
8269  return m_device;
8270  }
8271 
8272  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
8273  {
8274  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
8275  return m_dispatcher;
8276  }
8277 
8278  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Event & rhs ) VULKAN_HPP_NOEXCEPT
8279  {
8280  std::swap( m_device, rhs.m_device );
8281  std::swap( m_event, rhs.m_event );
8282  std::swap( m_allocator, rhs.m_allocator );
8283  std::swap( m_dispatcher, rhs.m_dispatcher );
8284  }
8285 
8286  //=== VK_VERSION_1_0 ===
8287 
8289 
8290  void set() const;
8291 
8292  void reset() const;
8293 
8294  private:
8295  VULKAN_HPP_NAMESPACE::Device m_device = {};
8296  VULKAN_HPP_NAMESPACE::Event m_event = {};
8297  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
8298  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
8299  };
8300 
8301  class Fence
8302  {
8303  public:
8304  using CType = VkFence;
8306 
8307  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eFence;
8309  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFence;
8310 
8311  public:
8312 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
8313  Fence( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
8314  VULKAN_HPP_NAMESPACE::FenceCreateInfo const & createInfo,
8315  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
8316  {
8317  *this = device.createFence( createInfo, allocator );
8318  }
8319 # endif
8320 
8321 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
8322  Fence( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
8323  VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT const & deviceEventInfo,
8324  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
8325  {
8326  *this = device.registerEventEXT( deviceEventInfo, allocator );
8327  }
8328 # endif
8329 
8330 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
8331  Fence( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
8332  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const & display,
8333  VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT const & displayEventInfo,
8334  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
8335  {
8336  *this = device.registerDisplayEventEXT( display, displayEventInfo, allocator );
8337  }
8338 # endif
8339 
8340  Fence( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
8341  VkFence fence,
8342  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
8343  : m_device( device )
8344  , m_fence( fence )
8345  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
8346  , m_dispatcher( device.getDispatcher() )
8347  {
8348  }
8349 
8350  Fence( std::nullptr_t ) {}
8351 
8353  {
8354  clear();
8355  }
8356 
8357  Fence() = delete;
8358  Fence( Fence const & ) = delete;
8359 
8361  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
8362  , m_fence( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_fence, {} ) )
8363  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
8364  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
8365  {
8366  }
8367 
8368  Fence & operator=( Fence const & ) = delete;
8369 
8371  {
8372  if ( this != &rhs )
8373  {
8374  std::swap( m_device, rhs.m_device );
8375  std::swap( m_fence, rhs.m_fence );
8376  std::swap( m_allocator, rhs.m_allocator );
8377  std::swap( m_dispatcher, rhs.m_dispatcher );
8378  }
8379  return *this;
8380  }
8381 
8382  VULKAN_HPP_NAMESPACE::Fence const & operator*() const VULKAN_HPP_NOEXCEPT
8383  {
8384  return m_fence;
8385  }
8386 
8387  operator VULKAN_HPP_NAMESPACE::Fence() const VULKAN_HPP_NOEXCEPT
8388  {
8389  return m_fence;
8390  }
8391 
8393  {
8394  if ( m_fence )
8395  {
8396  getDispatcher()->vkDestroyFence(
8397  static_cast<VkDevice>( m_device ), static_cast<VkFence>( m_fence ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
8398  }
8399  m_device = nullptr;
8400  m_fence = nullptr;
8401  m_allocator = nullptr;
8402  m_dispatcher = nullptr;
8403  }
8404 
8405  VULKAN_HPP_NAMESPACE::Fence release()
8406  {
8407  m_device = nullptr;
8408  m_allocator = nullptr;
8409  m_dispatcher = nullptr;
8411  }
8412 
8413  VULKAN_HPP_NAMESPACE::Device getDevice() const
8414  {
8415  return m_device;
8416  }
8417 
8418  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
8419  {
8420  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
8421  return m_dispatcher;
8422  }
8423 
8424  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Fence & rhs ) VULKAN_HPP_NOEXCEPT
8425  {
8426  std::swap( m_device, rhs.m_device );
8427  std::swap( m_fence, rhs.m_fence );
8428  std::swap( m_allocator, rhs.m_allocator );
8429  std::swap( m_dispatcher, rhs.m_dispatcher );
8430  }
8431 
8432  //=== VK_VERSION_1_0 ===
8433 
8435 
8436  private:
8437  VULKAN_HPP_NAMESPACE::Device m_device = {};
8438  VULKAN_HPP_NAMESPACE::Fence m_fence = {};
8439  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
8440  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
8441  };
8442 
8444  {
8445  public:
8448 
8449  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eFramebuffer;
8451  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eFramebuffer;
8452 
8453  public:
8454 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
8455  Framebuffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
8456  VULKAN_HPP_NAMESPACE::FramebufferCreateInfo const & createInfo,
8457  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
8458  {
8459  *this = device.createFramebuffer( createInfo, allocator );
8460  }
8461 # endif
8462 
8463  Framebuffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
8464  VkFramebuffer framebuffer,
8465  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
8466  : m_device( device )
8467  , m_framebuffer( framebuffer )
8468  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
8469  , m_dispatcher( device.getDispatcher() )
8470  {
8471  }
8472 
8473  Framebuffer( std::nullptr_t ) {}
8474 
8476  {
8477  clear();
8478  }
8479 
8480  Framebuffer() = delete;
8481  Framebuffer( Framebuffer const & ) = delete;
8482 
8484  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
8485  , m_framebuffer( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_framebuffer, {} ) )
8486  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
8487  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
8488  {
8489  }
8490 
8491  Framebuffer & operator=( Framebuffer const & ) = delete;
8492 
8494  {
8495  if ( this != &rhs )
8496  {
8497  std::swap( m_device, rhs.m_device );
8498  std::swap( m_framebuffer, rhs.m_framebuffer );
8499  std::swap( m_allocator, rhs.m_allocator );
8500  std::swap( m_dispatcher, rhs.m_dispatcher );
8501  }
8502  return *this;
8503  }
8504 
8505  VULKAN_HPP_NAMESPACE::Framebuffer const & operator*() const VULKAN_HPP_NOEXCEPT
8506  {
8507  return m_framebuffer;
8508  }
8509 
8510  operator VULKAN_HPP_NAMESPACE::Framebuffer() const VULKAN_HPP_NOEXCEPT
8511  {
8512  return m_framebuffer;
8513  }
8514 
8516  {
8517  if ( m_framebuffer )
8518  {
8519  getDispatcher()->vkDestroyFramebuffer(
8520  static_cast<VkDevice>( m_device ), static_cast<VkFramebuffer>( m_framebuffer ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
8521  }
8522  m_device = nullptr;
8523  m_framebuffer = nullptr;
8524  m_allocator = nullptr;
8525  m_dispatcher = nullptr;
8526  }
8527 
8528  VULKAN_HPP_NAMESPACE::Framebuffer release()
8529  {
8530  m_device = nullptr;
8531  m_allocator = nullptr;
8532  m_dispatcher = nullptr;
8533  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_framebuffer, nullptr );
8534  }
8535 
8536  VULKAN_HPP_NAMESPACE::Device getDevice() const
8537  {
8538  return m_device;
8539  }
8540 
8541  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
8542  {
8543  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
8544  return m_dispatcher;
8545  }
8546 
8547  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Framebuffer & rhs ) VULKAN_HPP_NOEXCEPT
8548  {
8549  std::swap( m_device, rhs.m_device );
8550  std::swap( m_framebuffer, rhs.m_framebuffer );
8551  std::swap( m_allocator, rhs.m_allocator );
8552  std::swap( m_dispatcher, rhs.m_dispatcher );
8553  }
8554 
8555  //=== VK_QCOM_tile_properties ===
8556 
8557  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM> getTilePropertiesQCOM() const;
8558 
8559  private:
8560  VULKAN_HPP_NAMESPACE::Device m_device = {};
8561  VULKAN_HPP_NAMESPACE::Framebuffer m_framebuffer = {};
8562  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
8563  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
8564  };
8565 
8566  class Image
8567  {
8568  public:
8569  using CType = VkImage;
8571 
8572  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eImage;
8574  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImage;
8575 
8576  public:
8577 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
8578  Image( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
8579  VULKAN_HPP_NAMESPACE::ImageCreateInfo const & createInfo,
8580  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
8581  {
8582  *this = device.createImage( createInfo, allocator );
8583  }
8584 # endif
8585 
8586  Image( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
8587  VkImage image,
8588  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
8589  : m_device( device )
8590  , m_image( image )
8591  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
8592  , m_dispatcher( device.getDispatcher() )
8593  {
8594  }
8595 
8596  Image( std::nullptr_t ) {}
8597 
8599  {
8600  clear();
8601  }
8602 
8603  Image() = delete;
8604  Image( Image const & ) = delete;
8605 
8607  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
8608  , m_image( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_image, {} ) )
8609  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
8610  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
8611  {
8612  }
8613 
8614  Image & operator=( Image const & ) = delete;
8615 
8617  {
8618  if ( this != &rhs )
8619  {
8620  std::swap( m_device, rhs.m_device );
8621  std::swap( m_image, rhs.m_image );
8622  std::swap( m_allocator, rhs.m_allocator );
8623  std::swap( m_dispatcher, rhs.m_dispatcher );
8624  }
8625  return *this;
8626  }
8627 
8628  VULKAN_HPP_NAMESPACE::Image const & operator*() const VULKAN_HPP_NOEXCEPT
8629  {
8630  return m_image;
8631  }
8632 
8633  operator VULKAN_HPP_NAMESPACE::Image() const VULKAN_HPP_NOEXCEPT
8634  {
8635  return m_image;
8636  }
8637 
8639  {
8640  if ( m_image )
8641  {
8642  getDispatcher()->vkDestroyImage(
8643  static_cast<VkDevice>( m_device ), static_cast<VkImage>( m_image ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
8644  }
8645  m_device = nullptr;
8646  m_image = nullptr;
8647  m_allocator = nullptr;
8648  m_dispatcher = nullptr;
8649  }
8650 
8651  VULKAN_HPP_NAMESPACE::Image release()
8652  {
8653  m_device = nullptr;
8654  m_allocator = nullptr;
8655  m_dispatcher = nullptr;
8657  }
8658 
8659  VULKAN_HPP_NAMESPACE::Device getDevice() const
8660  {
8661  return m_device;
8662  }
8663 
8664  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
8665  {
8666  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
8667  return m_dispatcher;
8668  }
8669 
8670  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Image & rhs ) VULKAN_HPP_NOEXCEPT
8671  {
8672  std::swap( m_device, rhs.m_device );
8673  std::swap( m_image, rhs.m_image );
8674  std::swap( m_allocator, rhs.m_allocator );
8675  std::swap( m_dispatcher, rhs.m_dispatcher );
8676  }
8677 
8678  //=== VK_VERSION_1_0 ===
8679 
8680  void bindMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset ) const;
8681 
8682  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::MemoryRequirements getMemoryRequirements() const VULKAN_HPP_NOEXCEPT;
8683 
8684  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements> getSparseMemoryRequirements() const;
8685 
8686  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout
8687  getSubresourceLayout( const VULKAN_HPP_NAMESPACE::ImageSubresource & subresource ) const VULKAN_HPP_NOEXCEPT;
8688 
8689  //=== VK_EXT_image_drm_format_modifier ===
8690 
8691  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT getDrmFormatModifierPropertiesEXT() const;
8692 
8693  //=== VK_EXT_host_image_copy ===
8694 
8695  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR
8696  getSubresourceLayout2EXT( const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR & subresource ) const VULKAN_HPP_NOEXCEPT;
8697 
8698  template <typename X, typename Y, typename... Z>
8699  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
8700  getSubresourceLayout2EXT( const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR & subresource ) const VULKAN_HPP_NOEXCEPT;
8701 
8702  //=== VK_KHR_maintenance5 ===
8703 
8704  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR
8705  getSubresourceLayout2KHR( const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR & subresource ) const VULKAN_HPP_NOEXCEPT;
8706 
8707  template <typename X, typename Y, typename... Z>
8708  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
8709  getSubresourceLayout2KHR( const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR & subresource ) const VULKAN_HPP_NOEXCEPT;
8710 
8711  private:
8712  VULKAN_HPP_NAMESPACE::Device m_device = {};
8713  VULKAN_HPP_NAMESPACE::Image m_image = {};
8714  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
8715  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
8716  };
8717 
8719  {
8720  public:
8723 
8724  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eImageView;
8726  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eImageView;
8727 
8728  public:
8729 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
8730  ImageView( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
8731  VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const & createInfo,
8732  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
8733  {
8734  *this = device.createImageView( createInfo, allocator );
8735  }
8736 # endif
8737 
8738  ImageView( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
8739  VkImageView imageView,
8740  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
8741  : m_device( device )
8742  , m_imageView( imageView )
8743  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
8744  , m_dispatcher( device.getDispatcher() )
8745  {
8746  }
8747 
8748  ImageView( std::nullptr_t ) {}
8749 
8751  {
8752  clear();
8753  }
8754 
8755  ImageView() = delete;
8756  ImageView( ImageView const & ) = delete;
8757 
8759  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
8760  , m_imageView( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_imageView, {} ) )
8761  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
8762  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
8763  {
8764  }
8765 
8766  ImageView & operator=( ImageView const & ) = delete;
8767 
8769  {
8770  if ( this != &rhs )
8771  {
8772  std::swap( m_device, rhs.m_device );
8773  std::swap( m_imageView, rhs.m_imageView );
8774  std::swap( m_allocator, rhs.m_allocator );
8775  std::swap( m_dispatcher, rhs.m_dispatcher );
8776  }
8777  return *this;
8778  }
8779 
8780  VULKAN_HPP_NAMESPACE::ImageView const & operator*() const VULKAN_HPP_NOEXCEPT
8781  {
8782  return m_imageView;
8783  }
8784 
8785  operator VULKAN_HPP_NAMESPACE::ImageView() const VULKAN_HPP_NOEXCEPT
8786  {
8787  return m_imageView;
8788  }
8789 
8791  {
8792  if ( m_imageView )
8793  {
8794  getDispatcher()->vkDestroyImageView(
8795  static_cast<VkDevice>( m_device ), static_cast<VkImageView>( m_imageView ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
8796  }
8797  m_device = nullptr;
8798  m_imageView = nullptr;
8799  m_allocator = nullptr;
8800  m_dispatcher = nullptr;
8801  }
8802 
8803  VULKAN_HPP_NAMESPACE::ImageView release()
8804  {
8805  m_device = nullptr;
8806  m_allocator = nullptr;
8807  m_dispatcher = nullptr;
8808  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_imageView, nullptr );
8809  }
8810 
8811  VULKAN_HPP_NAMESPACE::Device getDevice() const
8812  {
8813  return m_device;
8814  }
8815 
8816  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
8817  {
8818  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
8819  return m_dispatcher;
8820  }
8821 
8822  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ImageView & rhs ) VULKAN_HPP_NOEXCEPT
8823  {
8824  std::swap( m_device, rhs.m_device );
8825  std::swap( m_imageView, rhs.m_imageView );
8826  std::swap( m_allocator, rhs.m_allocator );
8827  std::swap( m_dispatcher, rhs.m_dispatcher );
8828  }
8829 
8830  //=== VK_NVX_image_view_handle ===
8831 
8832  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX getAddressNVX() const;
8833 
8834  private:
8835  VULKAN_HPP_NAMESPACE::Device m_device = {};
8836  VULKAN_HPP_NAMESPACE::ImageView m_imageView = {};
8837  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
8838  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
8839  };
8840 
8842  {
8843  public:
8846 
8847  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutNV;
8849  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
8850 
8851  public:
8852 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
8853  IndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
8854  VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV const & createInfo,
8855  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
8856  {
8857  *this = device.createIndirectCommandsLayoutNV( createInfo, allocator );
8858  }
8859 # endif
8860 
8861  IndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
8862  VkIndirectCommandsLayoutNV indirectCommandsLayout,
8863  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
8864  : m_device( device )
8865  , m_indirectCommandsLayout( indirectCommandsLayout )
8866  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
8867  , m_dispatcher( device.getDispatcher() )
8868  {
8869  }
8870 
8871  IndirectCommandsLayoutNV( std::nullptr_t ) {}
8872 
8874  {
8875  clear();
8876  }
8877 
8880 
8882  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
8883  , m_indirectCommandsLayout( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_indirectCommandsLayout, {} ) )
8884  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
8885  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
8886  {
8887  }
8888 
8890 
8892  {
8893  if ( this != &rhs )
8894  {
8895  std::swap( m_device, rhs.m_device );
8896  std::swap( m_indirectCommandsLayout, rhs.m_indirectCommandsLayout );
8897  std::swap( m_allocator, rhs.m_allocator );
8898  std::swap( m_dispatcher, rhs.m_dispatcher );
8899  }
8900  return *this;
8901  }
8902 
8903  VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV const & operator*() const VULKAN_HPP_NOEXCEPT
8904  {
8905  return m_indirectCommandsLayout;
8906  }
8907 
8908  operator VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV() const VULKAN_HPP_NOEXCEPT
8909  {
8910  return m_indirectCommandsLayout;
8911  }
8912 
8914  {
8915  if ( m_indirectCommandsLayout )
8916  {
8917  getDispatcher()->vkDestroyIndirectCommandsLayoutNV( static_cast<VkDevice>( m_device ),
8918  static_cast<VkIndirectCommandsLayoutNV>( m_indirectCommandsLayout ),
8919  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
8920  }
8921  m_device = nullptr;
8922  m_indirectCommandsLayout = nullptr;
8923  m_allocator = nullptr;
8924  m_dispatcher = nullptr;
8925  }
8926 
8927  VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV release()
8928  {
8929  m_device = nullptr;
8930  m_allocator = nullptr;
8931  m_dispatcher = nullptr;
8932  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_indirectCommandsLayout, nullptr );
8933  }
8934 
8935  VULKAN_HPP_NAMESPACE::Device getDevice() const
8936  {
8937  return m_device;
8938  }
8939 
8940  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
8941  {
8942  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
8943  return m_dispatcher;
8944  }
8945 
8946  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::IndirectCommandsLayoutNV & rhs ) VULKAN_HPP_NOEXCEPT
8947  {
8948  std::swap( m_device, rhs.m_device );
8949  std::swap( m_indirectCommandsLayout, rhs.m_indirectCommandsLayout );
8950  std::swap( m_allocator, rhs.m_allocator );
8951  std::swap( m_dispatcher, rhs.m_dispatcher );
8952  }
8953 
8954  private:
8955  VULKAN_HPP_NAMESPACE::Device m_device = {};
8956  VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV m_indirectCommandsLayout = {};
8957  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
8958  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
8959  };
8960 
8962  {
8963  public:
8966 
8967  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eMicromapEXT;
8969  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
8970 
8971  public:
8972 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
8973  MicromapEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
8974  VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT const & createInfo,
8975  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
8976  {
8977  *this = device.createMicromapEXT( createInfo, allocator );
8978  }
8979 # endif
8980 
8981  MicromapEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
8982  VkMicromapEXT micromap,
8983  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
8984  : m_device( device )
8985  , m_micromap( micromap )
8986  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
8987  , m_dispatcher( device.getDispatcher() )
8988  {
8989  }
8990 
8991  MicromapEXT( std::nullptr_t ) {}
8992 
8994  {
8995  clear();
8996  }
8997 
8998  MicromapEXT() = delete;
8999  MicromapEXT( MicromapEXT const & ) = delete;
9000 
9002  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
9003  , m_micromap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_micromap, {} ) )
9004  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
9005  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
9006  {
9007  }
9008 
9009  MicromapEXT & operator=( MicromapEXT const & ) = delete;
9010 
9012  {
9013  if ( this != &rhs )
9014  {
9015  std::swap( m_device, rhs.m_device );
9016  std::swap( m_micromap, rhs.m_micromap );
9017  std::swap( m_allocator, rhs.m_allocator );
9018  std::swap( m_dispatcher, rhs.m_dispatcher );
9019  }
9020  return *this;
9021  }
9022 
9023  VULKAN_HPP_NAMESPACE::MicromapEXT const & operator*() const VULKAN_HPP_NOEXCEPT
9024  {
9025  return m_micromap;
9026  }
9027 
9028  operator VULKAN_HPP_NAMESPACE::MicromapEXT() const VULKAN_HPP_NOEXCEPT
9029  {
9030  return m_micromap;
9031  }
9032 
9034  {
9035  if ( m_micromap )
9036  {
9037  getDispatcher()->vkDestroyMicromapEXT(
9038  static_cast<VkDevice>( m_device ), static_cast<VkMicromapEXT>( m_micromap ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
9039  }
9040  m_device = nullptr;
9041  m_micromap = nullptr;
9042  m_allocator = nullptr;
9043  m_dispatcher = nullptr;
9044  }
9045 
9046  VULKAN_HPP_NAMESPACE::MicromapEXT release()
9047  {
9048  m_device = nullptr;
9049  m_allocator = nullptr;
9050  m_dispatcher = nullptr;
9051  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_micromap, nullptr );
9052  }
9053 
9054  VULKAN_HPP_NAMESPACE::Device getDevice() const
9055  {
9056  return m_device;
9057  }
9058 
9059  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
9060  {
9061  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
9062  return m_dispatcher;
9063  }
9064 
9065  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::MicromapEXT & rhs ) VULKAN_HPP_NOEXCEPT
9066  {
9067  std::swap( m_device, rhs.m_device );
9068  std::swap( m_micromap, rhs.m_micromap );
9069  std::swap( m_allocator, rhs.m_allocator );
9070  std::swap( m_dispatcher, rhs.m_dispatcher );
9071  }
9072 
9073  private:
9074  VULKAN_HPP_NAMESPACE::Device m_device = {};
9075  VULKAN_HPP_NAMESPACE::MicromapEXT m_micromap = {};
9076  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
9077  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
9078  };
9079 
9081  {
9082  public:
9085 
9086  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eOpticalFlowSessionNV;
9088  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
9089 
9090  public:
9091 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
9092  OpticalFlowSessionNV( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
9093  VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV const & createInfo,
9094  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
9095  {
9096  *this = device.createOpticalFlowSessionNV( createInfo, allocator );
9097  }
9098 # endif
9099 
9100  OpticalFlowSessionNV( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
9101  VkOpticalFlowSessionNV session,
9102  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
9103  : m_device( device )
9104  , m_session( session )
9105  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
9106  , m_dispatcher( device.getDispatcher() )
9107  {
9108  }
9109 
9110  OpticalFlowSessionNV( std::nullptr_t ) {}
9111 
9113  {
9114  clear();
9115  }
9116 
9119 
9121  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
9122  , m_session( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_session, {} ) )
9123  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
9124  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
9125  {
9126  }
9127 
9129 
9131  {
9132  if ( this != &rhs )
9133  {
9134  std::swap( m_device, rhs.m_device );
9135  std::swap( m_session, rhs.m_session );
9136  std::swap( m_allocator, rhs.m_allocator );
9137  std::swap( m_dispatcher, rhs.m_dispatcher );
9138  }
9139  return *this;
9140  }
9141 
9142  VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV const & operator*() const VULKAN_HPP_NOEXCEPT
9143  {
9144  return m_session;
9145  }
9146 
9147  operator VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV() const VULKAN_HPP_NOEXCEPT
9148  {
9149  return m_session;
9150  }
9151 
9153  {
9154  if ( m_session )
9155  {
9156  getDispatcher()->vkDestroyOpticalFlowSessionNV( static_cast<VkDevice>( m_device ),
9157  static_cast<VkOpticalFlowSessionNV>( m_session ),
9158  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
9159  }
9160  m_device = nullptr;
9161  m_session = nullptr;
9162  m_allocator = nullptr;
9163  m_dispatcher = nullptr;
9164  }
9165 
9166  VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV release()
9167  {
9168  m_device = nullptr;
9169  m_allocator = nullptr;
9170  m_dispatcher = nullptr;
9171  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_session, nullptr );
9172  }
9173 
9174  VULKAN_HPP_NAMESPACE::Device getDevice() const
9175  {
9176  return m_device;
9177  }
9178 
9179  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
9180  {
9181  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
9182  return m_dispatcher;
9183  }
9184 
9185  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::OpticalFlowSessionNV & rhs ) VULKAN_HPP_NOEXCEPT
9186  {
9187  std::swap( m_device, rhs.m_device );
9188  std::swap( m_session, rhs.m_session );
9189  std::swap( m_allocator, rhs.m_allocator );
9190  std::swap( m_dispatcher, rhs.m_dispatcher );
9191  }
9192 
9193  //=== VK_NV_optical_flow ===
9194 
9195  void bindImage( VULKAN_HPP_NAMESPACE::OpticalFlowSessionBindingPointNV bindingPoint,
9196  VULKAN_HPP_NAMESPACE::ImageView view,
9197  VULKAN_HPP_NAMESPACE::ImageLayout layout ) const;
9198 
9199  private:
9200  VULKAN_HPP_NAMESPACE::Device m_device = {};
9201  VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV m_session = {};
9202  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
9203  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
9204  };
9205 
9207  {
9208  public:
9211 
9212  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePerformanceConfigurationINTEL;
9214  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
9215 
9216  public:
9217 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
9218  PerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
9219  VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const & acquireInfo )
9220  {
9221  *this = device.acquirePerformanceConfigurationINTEL( acquireInfo );
9222  }
9223 # endif
9224 
9225  PerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkPerformanceConfigurationINTEL configuration )
9226  : m_device( device ), m_configuration( configuration ), m_dispatcher( device.getDispatcher() )
9227  {
9228  }
9229 
9230  PerformanceConfigurationINTEL( std::nullptr_t ) {}
9231 
9233  {
9234  clear();
9235  }
9236 
9239 
9241  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
9242  , m_configuration( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_configuration, {} ) )
9243  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
9244  {
9245  }
9246 
9248 
9250  {
9251  if ( this != &rhs )
9252  {
9253  std::swap( m_device, rhs.m_device );
9254  std::swap( m_configuration, rhs.m_configuration );
9255  std::swap( m_dispatcher, rhs.m_dispatcher );
9256  }
9257  return *this;
9258  }
9259 
9260  VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL const & operator*() const VULKAN_HPP_NOEXCEPT
9261  {
9262  return m_configuration;
9263  }
9264 
9265  operator VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL() const VULKAN_HPP_NOEXCEPT
9266  {
9267  return m_configuration;
9268  }
9269 
9271  {
9272  if ( m_configuration )
9273  {
9274  getDispatcher()->vkReleasePerformanceConfigurationINTEL( static_cast<VkDevice>( m_device ),
9275  static_cast<VkPerformanceConfigurationINTEL>( m_configuration ) );
9276  }
9277  m_device = nullptr;
9278  m_configuration = nullptr;
9279  m_dispatcher = nullptr;
9280  }
9281 
9282  VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL release()
9283  {
9284  m_device = nullptr;
9285  m_dispatcher = nullptr;
9286  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_configuration, nullptr );
9287  }
9288 
9289  VULKAN_HPP_NAMESPACE::Device getDevice() const
9290  {
9291  return m_device;
9292  }
9293 
9294  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
9295  {
9296  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
9297  return m_dispatcher;
9298  }
9299 
9300  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PerformanceConfigurationINTEL & rhs ) VULKAN_HPP_NOEXCEPT
9301  {
9302  std::swap( m_device, rhs.m_device );
9303  std::swap( m_configuration, rhs.m_configuration );
9304  std::swap( m_dispatcher, rhs.m_dispatcher );
9305  }
9306 
9307  private:
9308  VULKAN_HPP_NAMESPACE::Device m_device = {};
9309  VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL m_configuration = {};
9310  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
9311  };
9312 
9314  {
9315  public:
9318 
9319  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipelineCache;
9321  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineCache;
9322 
9323  public:
9324 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
9325  PipelineCache( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
9326  VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo const & createInfo,
9327  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
9328  {
9329  *this = device.createPipelineCache( createInfo, allocator );
9330  }
9331 # endif
9332 
9333  PipelineCache( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
9334  VkPipelineCache pipelineCache,
9335  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
9336  : m_device( device )
9337  , m_pipelineCache( pipelineCache )
9338  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
9339  , m_dispatcher( device.getDispatcher() )
9340  {
9341  }
9342 
9343  PipelineCache( std::nullptr_t ) {}
9344 
9346  {
9347  clear();
9348  }
9349 
9350  PipelineCache() = delete;
9351  PipelineCache( PipelineCache const & ) = delete;
9352 
9354  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
9355  , m_pipelineCache( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_pipelineCache, {} ) )
9356  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
9357  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
9358  {
9359  }
9360 
9361  PipelineCache & operator=( PipelineCache const & ) = delete;
9362 
9364  {
9365  if ( this != &rhs )
9366  {
9367  std::swap( m_device, rhs.m_device );
9368  std::swap( m_pipelineCache, rhs.m_pipelineCache );
9369  std::swap( m_allocator, rhs.m_allocator );
9370  std::swap( m_dispatcher, rhs.m_dispatcher );
9371  }
9372  return *this;
9373  }
9374 
9375  VULKAN_HPP_NAMESPACE::PipelineCache const & operator*() const VULKAN_HPP_NOEXCEPT
9376  {
9377  return m_pipelineCache;
9378  }
9379 
9380  operator VULKAN_HPP_NAMESPACE::PipelineCache() const VULKAN_HPP_NOEXCEPT
9381  {
9382  return m_pipelineCache;
9383  }
9384 
9386  {
9387  if ( m_pipelineCache )
9388  {
9389  getDispatcher()->vkDestroyPipelineCache( static_cast<VkDevice>( m_device ),
9390  static_cast<VkPipelineCache>( m_pipelineCache ),
9391  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
9392  }
9393  m_device = nullptr;
9394  m_pipelineCache = nullptr;
9395  m_allocator = nullptr;
9396  m_dispatcher = nullptr;
9397  }
9398 
9399  VULKAN_HPP_NAMESPACE::PipelineCache release()
9400  {
9401  m_device = nullptr;
9402  m_allocator = nullptr;
9403  m_dispatcher = nullptr;
9404  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_pipelineCache, nullptr );
9405  }
9406 
9407  VULKAN_HPP_NAMESPACE::Device getDevice() const
9408  {
9409  return m_device;
9410  }
9411 
9412  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
9413  {
9414  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
9415  return m_dispatcher;
9416  }
9417 
9418  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache & rhs ) VULKAN_HPP_NOEXCEPT
9419  {
9420  std::swap( m_device, rhs.m_device );
9421  std::swap( m_pipelineCache, rhs.m_pipelineCache );
9422  std::swap( m_allocator, rhs.m_allocator );
9423  std::swap( m_dispatcher, rhs.m_dispatcher );
9424  }
9425 
9426  //=== VK_VERSION_1_0 ===
9427 
9428  VULKAN_HPP_NODISCARD std::vector<uint8_t> getData() const;
9429 
9430  void merge( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::PipelineCache> const & srcCaches ) const;
9431 
9432  private:
9433  VULKAN_HPP_NAMESPACE::Device m_device = {};
9434  VULKAN_HPP_NAMESPACE::PipelineCache m_pipelineCache = {};
9435  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
9436  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
9437  };
9438 
9439  class Pipeline
9440  {
9441  public:
9444 
9445  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipeline;
9447  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipeline;
9448 
9449  public:
9450 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
9451  Pipeline( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
9452  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,
9453  VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo const & createInfo,
9454  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
9455  {
9456  *this = device.createComputePipeline( pipelineCache, createInfo, allocator );
9457  }
9458 # endif
9459 
9460 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
9461 # if defined( VK_ENABLE_BETA_EXTENSIONS )
9462  Pipeline( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
9463  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,
9464  VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX const & createInfo,
9465  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
9466  {
9467  *this = device.createExecutionGraphPipelineAMDX( pipelineCache, createInfo, allocator );
9468  }
9469 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
9470 # endif
9471 
9472 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
9473  Pipeline( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
9474  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,
9475  VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo const & createInfo,
9476  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
9477  {
9478  *this = device.createGraphicsPipeline( pipelineCache, createInfo, allocator );
9479  }
9480 # endif
9481 
9482 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
9483  Pipeline( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
9484  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR> const & deferredOperation,
9485  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,
9486  VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR const & createInfo,
9487  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
9488  {
9489  *this = device.createRayTracingPipelineKHR( deferredOperation, pipelineCache, createInfo, allocator );
9490  }
9491 # endif
9492 
9493 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
9494  Pipeline( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
9495  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,
9496  VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV const & createInfo,
9497  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
9498  {
9499  *this = device.createRayTracingPipelineNV( pipelineCache, createInfo, allocator );
9500  }
9501 # endif
9502 
9503  Pipeline( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
9504  VkPipeline pipeline,
9505  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr,
9506  VULKAN_HPP_NAMESPACE::Result successCode = VULKAN_HPP_NAMESPACE::Result::eSuccess )
9507  : m_device( device )
9508  , m_pipeline( pipeline )
9509  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
9510  , m_constructorSuccessCode( successCode )
9511  , m_dispatcher( device.getDispatcher() )
9512  {
9513  }
9514 
9515  Pipeline( std::nullptr_t ) {}
9516 
9518  {
9519  clear();
9520  }
9521 
9522  Pipeline() = delete;
9523  Pipeline( Pipeline const & ) = delete;
9524 
9526  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
9527  , m_pipeline( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_pipeline, {} ) )
9528  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
9529  , m_constructorSuccessCode( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_constructorSuccessCode, {} ) )
9530  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
9531  {
9532  }
9533 
9534  Pipeline & operator=( Pipeline const & ) = delete;
9535 
9537  {
9538  if ( this != &rhs )
9539  {
9540  std::swap( m_device, rhs.m_device );
9541  std::swap( m_pipeline, rhs.m_pipeline );
9542  std::swap( m_allocator, rhs.m_allocator );
9543  std::swap( m_constructorSuccessCode, rhs.m_constructorSuccessCode );
9544  std::swap( m_dispatcher, rhs.m_dispatcher );
9545  }
9546  return *this;
9547  }
9548 
9549  VULKAN_HPP_NAMESPACE::Pipeline const & operator*() const VULKAN_HPP_NOEXCEPT
9550  {
9551  return m_pipeline;
9552  }
9553 
9554  operator VULKAN_HPP_NAMESPACE::Pipeline() const VULKAN_HPP_NOEXCEPT
9555  {
9556  return m_pipeline;
9557  }
9558 
9560  {
9561  if ( m_pipeline )
9562  {
9563  getDispatcher()->vkDestroyPipeline(
9564  static_cast<VkDevice>( m_device ), static_cast<VkPipeline>( m_pipeline ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
9565  }
9566  m_device = nullptr;
9567  m_pipeline = nullptr;
9568  m_allocator = nullptr;
9569  m_constructorSuccessCode = VULKAN_HPP_NAMESPACE::Result::eErrorUnknown;
9570  m_dispatcher = nullptr;
9571  }
9572 
9573  VULKAN_HPP_NAMESPACE::Pipeline release()
9574  {
9575  m_device = nullptr;
9576  m_allocator = nullptr;
9577  m_constructorSuccessCode = VULKAN_HPP_NAMESPACE::Result::eErrorUnknown;
9578  m_dispatcher = nullptr;
9579  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_pipeline, nullptr );
9580  }
9581 
9583  {
9584  return m_constructorSuccessCode;
9585  }
9586 
9587  VULKAN_HPP_NAMESPACE::Device getDevice() const
9588  {
9589  return m_device;
9590  }
9591 
9592  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
9593  {
9594  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
9595  return m_dispatcher;
9596  }
9597 
9598  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline & rhs ) VULKAN_HPP_NOEXCEPT
9599  {
9600  std::swap( m_device, rhs.m_device );
9601  std::swap( m_pipeline, rhs.m_pipeline );
9602  std::swap( m_allocator, rhs.m_allocator );
9603  std::swap( m_constructorSuccessCode, rhs.m_constructorSuccessCode );
9604  std::swap( m_dispatcher, rhs.m_dispatcher );
9605  }
9606 
9607  //=== VK_AMD_shader_info ===
9608 
9609  VULKAN_HPP_NODISCARD std::vector<uint8_t> getShaderInfoAMD( VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
9610  VULKAN_HPP_NAMESPACE::ShaderInfoTypeAMD infoType ) const;
9611 
9612 # if defined( VK_ENABLE_BETA_EXTENSIONS )
9613  //=== VK_AMDX_shader_enqueue ===
9614 
9615  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX getExecutionGraphScratchSizeAMDX() const;
9616 
9617  VULKAN_HPP_NODISCARD uint32_t getExecutionGraphNodeIndexAMDX( const VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX & nodeInfo ) const;
9618 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
9619 
9620  //=== VK_KHR_ray_tracing_pipeline ===
9621 
9622  template <typename DataType>
9623  VULKAN_HPP_NODISCARD std::vector<DataType> getRayTracingShaderGroupHandlesKHR( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const;
9624 
9625  template <typename DataType>
9626  VULKAN_HPP_NODISCARD DataType getRayTracingShaderGroupHandleKHR( uint32_t firstGroup, uint32_t groupCount ) const;
9627 
9628  template <typename DataType>
9629  VULKAN_HPP_NODISCARD std::vector<DataType>
9630  getRayTracingCaptureReplayShaderGroupHandlesKHR( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const;
9631 
9632  template <typename DataType>
9633  VULKAN_HPP_NODISCARD DataType getRayTracingCaptureReplayShaderGroupHandleKHR( uint32_t firstGroup, uint32_t groupCount ) const;
9634 
9636  getRayTracingShaderGroupStackSizeKHR( uint32_t group, VULKAN_HPP_NAMESPACE::ShaderGroupShaderKHR groupShader ) const VULKAN_HPP_NOEXCEPT;
9637 
9638  //=== VK_NV_ray_tracing ===
9639 
9640  template <typename DataType>
9641  VULKAN_HPP_NODISCARD std::vector<DataType> getRayTracingShaderGroupHandlesNV( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const;
9642 
9643  template <typename DataType>
9644  VULKAN_HPP_NODISCARD DataType getRayTracingShaderGroupHandleNV( uint32_t firstGroup, uint32_t groupCount ) const;
9645 
9646  void compileDeferredNV( uint32_t shader ) const;
9647 
9648  private:
9649  VULKAN_HPP_NAMESPACE::Device m_device = {};
9650  VULKAN_HPP_NAMESPACE::Pipeline m_pipeline = {};
9651  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
9652  VULKAN_HPP_NAMESPACE::Result m_constructorSuccessCode = VULKAN_HPP_NAMESPACE::Result::eErrorUnknown;
9653  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
9654  };
9655 
9656  class Pipelines : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>
9657  {
9658  public:
9659 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
9660  Pipelines( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
9661  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,
9662  VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
9663  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
9664  {
9665  *this = device.createComputePipelines( pipelineCache, createInfos, allocator );
9666  }
9667 # endif
9668 
9669 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
9670 # if defined( VK_ENABLE_BETA_EXTENSIONS )
9671  Pipelines( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
9672  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,
9673  VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,
9674  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
9675  {
9676  *this = device.createExecutionGraphPipelinesAMDX( pipelineCache, createInfos, allocator );
9677  }
9678 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
9679 # endif
9680 
9681 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
9682  Pipelines( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
9683  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,
9684  VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
9685  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
9686  {
9687  *this = device.createGraphicsPipelines( pipelineCache, createInfos, allocator );
9688  }
9689 # endif
9690 
9691 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
9692  Pipelines( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
9693  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR> const & deferredOperation,
9694  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,
9695  VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
9696  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
9697  {
9698  *this = device.createRayTracingPipelinesKHR( deferredOperation, pipelineCache, createInfos, allocator );
9699  }
9700 # endif
9701 
9702 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
9703  Pipelines( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
9704  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,
9705  VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
9706  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
9707  {
9708  *this = device.createRayTracingPipelinesNV( pipelineCache, createInfos, allocator );
9709  }
9710 # endif
9711 
9712  Pipelines( std::nullptr_t ) {}
9713 
9714  Pipelines() = delete;
9715  Pipelines( Pipelines const & ) = delete;
9716  Pipelines( Pipelines && rhs ) = default;
9717  Pipelines & operator=( Pipelines const & ) = delete;
9718  Pipelines & operator=( Pipelines && rhs ) = default;
9719 
9720  private:
9721  Pipelines( std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline> && rhs )
9722  {
9723  std::swap( *this, rhs );
9724  }
9725  };
9726 
9728  {
9729  public:
9732 
9733  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePipelineLayout;
9735  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::ePipelineLayout;
9736 
9737  public:
9738 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
9739  PipelineLayout( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
9740  VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo const & createInfo,
9741  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
9742  {
9743  *this = device.createPipelineLayout( createInfo, allocator );
9744  }
9745 # endif
9746 
9747  PipelineLayout( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
9748  VkPipelineLayout pipelineLayout,
9749  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
9750  : m_device( device )
9751  , m_pipelineLayout( pipelineLayout )
9752  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
9753  , m_dispatcher( device.getDispatcher() )
9754  {
9755  }
9756 
9757  PipelineLayout( std::nullptr_t ) {}
9758 
9760  {
9761  clear();
9762  }
9763 
9764  PipelineLayout() = delete;
9765  PipelineLayout( PipelineLayout const & ) = delete;
9766 
9768  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
9769  , m_pipelineLayout( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_pipelineLayout, {} ) )
9770  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
9771  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
9772  {
9773  }
9774 
9775  PipelineLayout & operator=( PipelineLayout const & ) = delete;
9776 
9778  {
9779  if ( this != &rhs )
9780  {
9781  std::swap( m_device, rhs.m_device );
9782  std::swap( m_pipelineLayout, rhs.m_pipelineLayout );
9783  std::swap( m_allocator, rhs.m_allocator );
9784  std::swap( m_dispatcher, rhs.m_dispatcher );
9785  }
9786  return *this;
9787  }
9788 
9789  VULKAN_HPP_NAMESPACE::PipelineLayout const & operator*() const VULKAN_HPP_NOEXCEPT
9790  {
9791  return m_pipelineLayout;
9792  }
9793 
9794  operator VULKAN_HPP_NAMESPACE::PipelineLayout() const VULKAN_HPP_NOEXCEPT
9795  {
9796  return m_pipelineLayout;
9797  }
9798 
9800  {
9801  if ( m_pipelineLayout )
9802  {
9803  getDispatcher()->vkDestroyPipelineLayout( static_cast<VkDevice>( m_device ),
9804  static_cast<VkPipelineLayout>( m_pipelineLayout ),
9805  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
9806  }
9807  m_device = nullptr;
9808  m_pipelineLayout = nullptr;
9809  m_allocator = nullptr;
9810  m_dispatcher = nullptr;
9811  }
9812 
9813  VULKAN_HPP_NAMESPACE::PipelineLayout release()
9814  {
9815  m_device = nullptr;
9816  m_allocator = nullptr;
9817  m_dispatcher = nullptr;
9818  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_pipelineLayout, nullptr );
9819  }
9820 
9821  VULKAN_HPP_NAMESPACE::Device getDevice() const
9822  {
9823  return m_device;
9824  }
9825 
9826  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
9827  {
9828  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
9829  return m_dispatcher;
9830  }
9831 
9832  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineLayout & rhs ) VULKAN_HPP_NOEXCEPT
9833  {
9834  std::swap( m_device, rhs.m_device );
9835  std::swap( m_pipelineLayout, rhs.m_pipelineLayout );
9836  std::swap( m_allocator, rhs.m_allocator );
9837  std::swap( m_dispatcher, rhs.m_dispatcher );
9838  }
9839 
9840  private:
9841  VULKAN_HPP_NAMESPACE::Device m_device = {};
9842  VULKAN_HPP_NAMESPACE::PipelineLayout m_pipelineLayout = {};
9843  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
9844  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
9845  };
9846 
9848  {
9849  public:
9852 
9853  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::ePrivateDataSlot;
9855  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
9856 
9857  public:
9858 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
9859  PrivateDataSlot( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
9860  VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo const & createInfo,
9861  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
9862  {
9863  *this = device.createPrivateDataSlot( createInfo, allocator );
9864  }
9865 # endif
9866 
9867  PrivateDataSlot( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
9868  VkPrivateDataSlot privateDataSlot,
9869  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
9870  : m_device( device )
9871  , m_privateDataSlot( privateDataSlot )
9872  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
9873  , m_dispatcher( device.getDispatcher() )
9874  {
9875  }
9876 
9877  PrivateDataSlot( std::nullptr_t ) {}
9878 
9880  {
9881  clear();
9882  }
9883 
9884  PrivateDataSlot() = delete;
9885  PrivateDataSlot( PrivateDataSlot const & ) = delete;
9886 
9888  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
9889  , m_privateDataSlot( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_privateDataSlot, {} ) )
9890  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
9891  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
9892  {
9893  }
9894 
9896 
9898  {
9899  if ( this != &rhs )
9900  {
9901  std::swap( m_device, rhs.m_device );
9902  std::swap( m_privateDataSlot, rhs.m_privateDataSlot );
9903  std::swap( m_allocator, rhs.m_allocator );
9904  std::swap( m_dispatcher, rhs.m_dispatcher );
9905  }
9906  return *this;
9907  }
9908 
9909  VULKAN_HPP_NAMESPACE::PrivateDataSlot const & operator*() const VULKAN_HPP_NOEXCEPT
9910  {
9911  return m_privateDataSlot;
9912  }
9913 
9914  operator VULKAN_HPP_NAMESPACE::PrivateDataSlot() const VULKAN_HPP_NOEXCEPT
9915  {
9916  return m_privateDataSlot;
9917  }
9918 
9920  {
9921  if ( m_privateDataSlot )
9922  {
9923  getDispatcher()->vkDestroyPrivateDataSlot( static_cast<VkDevice>( m_device ),
9924  static_cast<VkPrivateDataSlot>( m_privateDataSlot ),
9925  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
9926  }
9927  m_device = nullptr;
9928  m_privateDataSlot = nullptr;
9929  m_allocator = nullptr;
9930  m_dispatcher = nullptr;
9931  }
9932 
9933  VULKAN_HPP_NAMESPACE::PrivateDataSlot release()
9934  {
9935  m_device = nullptr;
9936  m_allocator = nullptr;
9937  m_dispatcher = nullptr;
9938  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_privateDataSlot, nullptr );
9939  }
9940 
9941  VULKAN_HPP_NAMESPACE::Device getDevice() const
9942  {
9943  return m_device;
9944  }
9945 
9946  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
9947  {
9948  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
9949  return m_dispatcher;
9950  }
9951 
9952  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PrivateDataSlot & rhs ) VULKAN_HPP_NOEXCEPT
9953  {
9954  std::swap( m_device, rhs.m_device );
9955  std::swap( m_privateDataSlot, rhs.m_privateDataSlot );
9956  std::swap( m_allocator, rhs.m_allocator );
9957  std::swap( m_dispatcher, rhs.m_dispatcher );
9958  }
9959 
9960  private:
9961  VULKAN_HPP_NAMESPACE::Device m_device = {};
9962  VULKAN_HPP_NAMESPACE::PrivateDataSlot m_privateDataSlot = {};
9963  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
9964  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
9965  };
9966 
9968  {
9969  public:
9972 
9973  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eQueryPool;
9975  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueryPool;
9976 
9977  public:
9978 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
9979  QueryPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
9980  VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo const & createInfo,
9981  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
9982  {
9983  *this = device.createQueryPool( createInfo, allocator );
9984  }
9985 # endif
9986 
9987  QueryPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
9988  VkQueryPool queryPool,
9989  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
9990  : m_device( device )
9991  , m_queryPool( queryPool )
9992  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
9993  , m_dispatcher( device.getDispatcher() )
9994  {
9995  }
9996 
9997  QueryPool( std::nullptr_t ) {}
9998 
10000  {
10001  clear();
10002  }
10003 
10004  QueryPool() = delete;
10005  QueryPool( QueryPool const & ) = delete;
10006 
10008  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
10009  , m_queryPool( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_queryPool, {} ) )
10010  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
10011  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
10012  {
10013  }
10014 
10015  QueryPool & operator=( QueryPool const & ) = delete;
10016 
10018  {
10019  if ( this != &rhs )
10020  {
10021  std::swap( m_device, rhs.m_device );
10022  std::swap( m_queryPool, rhs.m_queryPool );
10023  std::swap( m_allocator, rhs.m_allocator );
10024  std::swap( m_dispatcher, rhs.m_dispatcher );
10025  }
10026  return *this;
10027  }
10028 
10029  VULKAN_HPP_NAMESPACE::QueryPool const & operator*() const VULKAN_HPP_NOEXCEPT
10030  {
10031  return m_queryPool;
10032  }
10033 
10034  operator VULKAN_HPP_NAMESPACE::QueryPool() const VULKAN_HPP_NOEXCEPT
10035  {
10036  return m_queryPool;
10037  }
10038 
10040  {
10041  if ( m_queryPool )
10042  {
10043  getDispatcher()->vkDestroyQueryPool(
10044  static_cast<VkDevice>( m_device ), static_cast<VkQueryPool>( m_queryPool ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
10045  }
10046  m_device = nullptr;
10047  m_queryPool = nullptr;
10048  m_allocator = nullptr;
10049  m_dispatcher = nullptr;
10050  }
10051 
10052  VULKAN_HPP_NAMESPACE::QueryPool release()
10053  {
10054  m_device = nullptr;
10055  m_allocator = nullptr;
10056  m_dispatcher = nullptr;
10057  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_queryPool, nullptr );
10058  }
10059 
10060  VULKAN_HPP_NAMESPACE::Device getDevice() const
10061  {
10062  return m_device;
10063  }
10064 
10065  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
10066  {
10067  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
10068  return m_dispatcher;
10069  }
10070 
10071  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::QueryPool & rhs ) VULKAN_HPP_NOEXCEPT
10072  {
10073  std::swap( m_device, rhs.m_device );
10074  std::swap( m_queryPool, rhs.m_queryPool );
10075  std::swap( m_allocator, rhs.m_allocator );
10076  std::swap( m_dispatcher, rhs.m_dispatcher );
10077  }
10078 
10079  //=== VK_VERSION_1_0 ===
10080 
10081  template <typename DataType>
10082  VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, std::vector<DataType>>
10083  getResults( uint32_t firstQuery,
10084  uint32_t queryCount,
10085  size_t dataSize,
10088 
10089  template <typename DataType>
10090  VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, DataType>
10091  getResult( uint32_t firstQuery,
10092  uint32_t queryCount,
10095 
10096  //=== VK_VERSION_1_2 ===
10097 
10098  void reset( uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT;
10099 
10100  //=== VK_EXT_host_query_reset ===
10101 
10102  void resetEXT( uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT;
10103 
10104  private:
10105  VULKAN_HPP_NAMESPACE::Device m_device = {};
10106  VULKAN_HPP_NAMESPACE::QueryPool m_queryPool = {};
10107  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
10108  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
10109  };
10110 
10111  class Queue
10112  {
10113  public:
10114  using CType = VkQueue;
10116 
10117  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eQueue;
10119  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eQueue;
10120 
10121  public:
10122 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
10123  Queue( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, uint32_t queueFamilyIndex, uint32_t queueIndex )
10124  {
10125  *this = device.getQueue( queueFamilyIndex, queueIndex );
10126  }
10127 # endif
10128 
10129 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
10130  Queue( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 const & queueInfo )
10131  {
10132  *this = device.getQueue2( queueInfo );
10133  }
10134 # endif
10135 
10136  Queue( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkQueue queue ) : m_queue( queue ), m_dispatcher( device.getDispatcher() )
10137  {
10138  }
10139 
10140  Queue( std::nullptr_t ) {}
10141 
10143  {
10144  clear();
10145  }
10146 
10147  Queue() = delete;
10148 
10149  Queue( Queue const & rhs ) : m_queue( rhs.m_queue ), m_dispatcher( rhs.m_dispatcher ) {}
10150 
10152  : m_queue( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_queue, {} ) )
10153  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
10154  {
10155  }
10156 
10157  Queue & operator=( Queue const & rhs )
10158  {
10159  m_queue = rhs.m_queue;
10160  m_dispatcher = rhs.m_dispatcher;
10161  return *this;
10162  }
10163 
10165  {
10166  if ( this != &rhs )
10167  {
10168  std::swap( m_queue, rhs.m_queue );
10169  std::swap( m_dispatcher, rhs.m_dispatcher );
10170  }
10171  return *this;
10172  }
10173 
10174  VULKAN_HPP_NAMESPACE::Queue const & operator*() const VULKAN_HPP_NOEXCEPT
10175  {
10176  return m_queue;
10177  }
10178 
10179  operator VULKAN_HPP_NAMESPACE::Queue() const VULKAN_HPP_NOEXCEPT
10180  {
10181  return m_queue;
10182  }
10183 
10185  {
10186  m_queue = nullptr;
10187  m_dispatcher = nullptr;
10188  }
10189 
10190  VULKAN_HPP_NAMESPACE::Queue release()
10191  {
10192  m_dispatcher = nullptr;
10194  }
10195 
10196  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
10197  {
10198  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
10199  return m_dispatcher;
10200  }
10201 
10202  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Queue & rhs ) VULKAN_HPP_NOEXCEPT
10203  {
10204  std::swap( m_queue, rhs.m_queue );
10205  std::swap( m_dispatcher, rhs.m_dispatcher );
10206  }
10207 
10208  //=== VK_VERSION_1_0 ===
10209 
10210  void submit( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo> const & submits,
10211  VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const;
10212 
10213  void waitIdle() const;
10214 
10215  void bindSparse( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindSparseInfo> const & bindInfo,
10216  VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const;
10217 
10218  //=== VK_VERSION_1_3 ===
10219 
10220  void submit2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2> const & submits,
10221  VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const;
10222 
10223  //=== VK_KHR_swapchain ===
10224 
10225  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR & presentInfo ) const;
10226 
10227  //=== VK_EXT_debug_utils ===
10228 
10229  void beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT;
10230 
10231  void endDebugUtilsLabelEXT() const VULKAN_HPP_NOEXCEPT;
10232 
10233  void insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT;
10234 
10235  //=== VK_NV_device_diagnostic_checkpoints ===
10236 
10237  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV> getCheckpointDataNV() const;
10238 
10239  //=== VK_INTEL_performance_query ===
10240 
10241  void setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration ) const;
10242 
10243  //=== VK_KHR_synchronization2 ===
10244 
10245  void submit2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2> const & submits,
10246  VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const;
10247 
10248  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV> getCheckpointData2NV() const;
10249 
10250  //=== VK_NV_low_latency2 ===
10251 
10252  void notifyOutOfBandNV( const VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV & queueTypeInfo ) const VULKAN_HPP_NOEXCEPT;
10253 
10254  private:
10255  VULKAN_HPP_NAMESPACE::Queue m_queue = {};
10256  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
10257  };
10258 
10260  {
10261  public:
10264 
10265  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eRenderPass;
10267  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eRenderPass;
10268 
10269  public:
10270 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
10271  RenderPass( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
10272  VULKAN_HPP_NAMESPACE::RenderPassCreateInfo const & createInfo,
10273  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
10274  {
10275  *this = device.createRenderPass( createInfo, allocator );
10276  }
10277 # endif
10278 
10279 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
10280  RenderPass( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
10281  VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & createInfo,
10282  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
10283  {
10284  *this = device.createRenderPass2( createInfo, allocator );
10285  }
10286 # endif
10287 
10288  RenderPass( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
10289  VkRenderPass renderPass,
10290  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
10291  : m_device( device )
10292  , m_renderPass( renderPass )
10293  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
10294  , m_dispatcher( device.getDispatcher() )
10295  {
10296  }
10297 
10298  RenderPass( std::nullptr_t ) {}
10299 
10301  {
10302  clear();
10303  }
10304 
10305  RenderPass() = delete;
10306  RenderPass( RenderPass const & ) = delete;
10307 
10309  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
10310  , m_renderPass( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_renderPass, {} ) )
10311  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
10312  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
10313  {
10314  }
10315 
10316  RenderPass & operator=( RenderPass const & ) = delete;
10317 
10319  {
10320  if ( this != &rhs )
10321  {
10322  std::swap( m_device, rhs.m_device );
10323  std::swap( m_renderPass, rhs.m_renderPass );
10324  std::swap( m_allocator, rhs.m_allocator );
10325  std::swap( m_dispatcher, rhs.m_dispatcher );
10326  }
10327  return *this;
10328  }
10329 
10330  VULKAN_HPP_NAMESPACE::RenderPass const & operator*() const VULKAN_HPP_NOEXCEPT
10331  {
10332  return m_renderPass;
10333  }
10334 
10335  operator VULKAN_HPP_NAMESPACE::RenderPass() const VULKAN_HPP_NOEXCEPT
10336  {
10337  return m_renderPass;
10338  }
10339 
10341  {
10342  if ( m_renderPass )
10343  {
10344  getDispatcher()->vkDestroyRenderPass(
10345  static_cast<VkDevice>( m_device ), static_cast<VkRenderPass>( m_renderPass ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
10346  }
10347  m_device = nullptr;
10348  m_renderPass = nullptr;
10349  m_allocator = nullptr;
10350  m_dispatcher = nullptr;
10351  }
10352 
10353  VULKAN_HPP_NAMESPACE::RenderPass release()
10354  {
10355  m_device = nullptr;
10356  m_allocator = nullptr;
10357  m_dispatcher = nullptr;
10358  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_renderPass, nullptr );
10359  }
10360 
10361  VULKAN_HPP_NAMESPACE::Device getDevice() const
10362  {
10363  return m_device;
10364  }
10365 
10366  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
10367  {
10368  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
10369  return m_dispatcher;
10370  }
10371 
10372  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::RenderPass & rhs ) VULKAN_HPP_NOEXCEPT
10373  {
10374  std::swap( m_device, rhs.m_device );
10375  std::swap( m_renderPass, rhs.m_renderPass );
10376  std::swap( m_allocator, rhs.m_allocator );
10377  std::swap( m_dispatcher, rhs.m_dispatcher );
10378  }
10379 
10380  //=== VK_VERSION_1_0 ===
10381 
10382  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Extent2D getRenderAreaGranularity() const VULKAN_HPP_NOEXCEPT;
10383 
10384  //=== VK_HUAWEI_subpass_shading ===
10385 
10386  VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, VULKAN_HPP_NAMESPACE::Extent2D> getSubpassShadingMaxWorkgroupSizeHUAWEI() const;
10387 
10388  private:
10389  VULKAN_HPP_NAMESPACE::Device m_device = {};
10390  VULKAN_HPP_NAMESPACE::RenderPass m_renderPass = {};
10391  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
10392  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
10393  };
10394 
10395  class Sampler
10396  {
10397  public:
10398  using CType = VkSampler;
10400 
10401  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSampler;
10403  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSampler;
10404 
10405  public:
10406 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
10407  Sampler( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
10408  VULKAN_HPP_NAMESPACE::SamplerCreateInfo const & createInfo,
10409  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
10410  {
10411  *this = device.createSampler( createInfo, allocator );
10412  }
10413 # endif
10414 
10415  Sampler( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
10416  VkSampler sampler,
10417  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
10418  : m_device( device )
10419  , m_sampler( sampler )
10420  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
10421  , m_dispatcher( device.getDispatcher() )
10422  {
10423  }
10424 
10425  Sampler( std::nullptr_t ) {}
10426 
10428  {
10429  clear();
10430  }
10431 
10432  Sampler() = delete;
10433  Sampler( Sampler const & ) = delete;
10434 
10436  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
10437  , m_sampler( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_sampler, {} ) )
10438  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
10439  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
10440  {
10441  }
10442 
10443  Sampler & operator=( Sampler const & ) = delete;
10444 
10446  {
10447  if ( this != &rhs )
10448  {
10449  std::swap( m_device, rhs.m_device );
10450  std::swap( m_sampler, rhs.m_sampler );
10451  std::swap( m_allocator, rhs.m_allocator );
10452  std::swap( m_dispatcher, rhs.m_dispatcher );
10453  }
10454  return *this;
10455  }
10456 
10457  VULKAN_HPP_NAMESPACE::Sampler const & operator*() const VULKAN_HPP_NOEXCEPT
10458  {
10459  return m_sampler;
10460  }
10461 
10462  operator VULKAN_HPP_NAMESPACE::Sampler() const VULKAN_HPP_NOEXCEPT
10463  {
10464  return m_sampler;
10465  }
10466 
10468  {
10469  if ( m_sampler )
10470  {
10471  getDispatcher()->vkDestroySampler(
10472  static_cast<VkDevice>( m_device ), static_cast<VkSampler>( m_sampler ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
10473  }
10474  m_device = nullptr;
10475  m_sampler = nullptr;
10476  m_allocator = nullptr;
10477  m_dispatcher = nullptr;
10478  }
10479 
10480  VULKAN_HPP_NAMESPACE::Sampler release()
10481  {
10482  m_device = nullptr;
10483  m_allocator = nullptr;
10484  m_dispatcher = nullptr;
10485  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_sampler, nullptr );
10486  }
10487 
10488  VULKAN_HPP_NAMESPACE::Device getDevice() const
10489  {
10490  return m_device;
10491  }
10492 
10493  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
10494  {
10495  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
10496  return m_dispatcher;
10497  }
10498 
10499  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Sampler & rhs ) VULKAN_HPP_NOEXCEPT
10500  {
10501  std::swap( m_device, rhs.m_device );
10502  std::swap( m_sampler, rhs.m_sampler );
10503  std::swap( m_allocator, rhs.m_allocator );
10504  std::swap( m_dispatcher, rhs.m_dispatcher );
10505  }
10506 
10507  private:
10508  VULKAN_HPP_NAMESPACE::Device m_device = {};
10509  VULKAN_HPP_NAMESPACE::Sampler m_sampler = {};
10510  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
10511  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
10512  };
10513 
10515  {
10516  public:
10519 
10520  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSamplerYcbcrConversion;
10522  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSamplerYcbcrConversion;
10523 
10524  public:
10525 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
10526  SamplerYcbcrConversion( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
10527  VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & createInfo,
10528  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
10529  {
10530  *this = device.createSamplerYcbcrConversion( createInfo, allocator );
10531  }
10532 # endif
10533 
10534  SamplerYcbcrConversion( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
10535  VkSamplerYcbcrConversion ycbcrConversion,
10536  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
10537  : m_device( device )
10538  , m_ycbcrConversion( ycbcrConversion )
10539  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
10540  , m_dispatcher( device.getDispatcher() )
10541  {
10542  }
10543 
10544  SamplerYcbcrConversion( std::nullptr_t ) {}
10545 
10547  {
10548  clear();
10549  }
10550 
10553 
10555  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
10556  , m_ycbcrConversion( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_ycbcrConversion, {} ) )
10557  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
10558  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
10559  {
10560  }
10561 
10563 
10565  {
10566  if ( this != &rhs )
10567  {
10568  std::swap( m_device, rhs.m_device );
10569  std::swap( m_ycbcrConversion, rhs.m_ycbcrConversion );
10570  std::swap( m_allocator, rhs.m_allocator );
10571  std::swap( m_dispatcher, rhs.m_dispatcher );
10572  }
10573  return *this;
10574  }
10575 
10576  VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const & operator*() const VULKAN_HPP_NOEXCEPT
10577  {
10578  return m_ycbcrConversion;
10579  }
10580 
10581  operator VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion() const VULKAN_HPP_NOEXCEPT
10582  {
10583  return m_ycbcrConversion;
10584  }
10585 
10587  {
10588  if ( m_ycbcrConversion )
10589  {
10590  getDispatcher()->vkDestroySamplerYcbcrConversion( static_cast<VkDevice>( m_device ),
10591  static_cast<VkSamplerYcbcrConversion>( m_ycbcrConversion ),
10592  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
10593  }
10594  m_device = nullptr;
10595  m_ycbcrConversion = nullptr;
10596  m_allocator = nullptr;
10597  m_dispatcher = nullptr;
10598  }
10599 
10600  VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion release()
10601  {
10602  m_device = nullptr;
10603  m_allocator = nullptr;
10604  m_dispatcher = nullptr;
10605  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_ycbcrConversion, nullptr );
10606  }
10607 
10608  VULKAN_HPP_NAMESPACE::Device getDevice() const
10609  {
10610  return m_device;
10611  }
10612 
10613  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
10614  {
10615  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
10616  return m_dispatcher;
10617  }
10618 
10619  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion & rhs ) VULKAN_HPP_NOEXCEPT
10620  {
10621  std::swap( m_device, rhs.m_device );
10622  std::swap( m_ycbcrConversion, rhs.m_ycbcrConversion );
10623  std::swap( m_allocator, rhs.m_allocator );
10624  std::swap( m_dispatcher, rhs.m_dispatcher );
10625  }
10626 
10627  private:
10628  VULKAN_HPP_NAMESPACE::Device m_device = {};
10629  VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion m_ycbcrConversion = {};
10630  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
10631  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
10632  };
10633 
10635  {
10636  public:
10639 
10640  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSemaphore;
10642  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSemaphore;
10643 
10644  public:
10645 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
10646  Semaphore( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
10647  VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo const & createInfo,
10648  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
10649  {
10650  *this = device.createSemaphore( createInfo, allocator );
10651  }
10652 # endif
10653 
10654  Semaphore( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
10655  VkSemaphore semaphore,
10656  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
10657  : m_device( device )
10658  , m_semaphore( semaphore )
10659  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
10660  , m_dispatcher( device.getDispatcher() )
10661  {
10662  }
10663 
10664  Semaphore( std::nullptr_t ) {}
10665 
10667  {
10668  clear();
10669  }
10670 
10671  Semaphore() = delete;
10672  Semaphore( Semaphore const & ) = delete;
10673 
10675  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
10676  , m_semaphore( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_semaphore, {} ) )
10677  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
10678  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
10679  {
10680  }
10681 
10682  Semaphore & operator=( Semaphore const & ) = delete;
10683 
10685  {
10686  if ( this != &rhs )
10687  {
10688  std::swap( m_device, rhs.m_device );
10689  std::swap( m_semaphore, rhs.m_semaphore );
10690  std::swap( m_allocator, rhs.m_allocator );
10691  std::swap( m_dispatcher, rhs.m_dispatcher );
10692  }
10693  return *this;
10694  }
10695 
10696  VULKAN_HPP_NAMESPACE::Semaphore const & operator*() const VULKAN_HPP_NOEXCEPT
10697  {
10698  return m_semaphore;
10699  }
10700 
10701  operator VULKAN_HPP_NAMESPACE::Semaphore() const VULKAN_HPP_NOEXCEPT
10702  {
10703  return m_semaphore;
10704  }
10705 
10707  {
10708  if ( m_semaphore )
10709  {
10710  getDispatcher()->vkDestroySemaphore(
10711  static_cast<VkDevice>( m_device ), static_cast<VkSemaphore>( m_semaphore ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
10712  }
10713  m_device = nullptr;
10714  m_semaphore = nullptr;
10715  m_allocator = nullptr;
10716  m_dispatcher = nullptr;
10717  }
10718 
10719  VULKAN_HPP_NAMESPACE::Semaphore release()
10720  {
10721  m_device = nullptr;
10722  m_allocator = nullptr;
10723  m_dispatcher = nullptr;
10724  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_semaphore, nullptr );
10725  }
10726 
10727  VULKAN_HPP_NAMESPACE::Device getDevice() const
10728  {
10729  return m_device;
10730  }
10731 
10732  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
10733  {
10734  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
10735  return m_dispatcher;
10736  }
10737 
10738  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Semaphore & rhs ) VULKAN_HPP_NOEXCEPT
10739  {
10740  std::swap( m_device, rhs.m_device );
10741  std::swap( m_semaphore, rhs.m_semaphore );
10742  std::swap( m_allocator, rhs.m_allocator );
10743  std::swap( m_dispatcher, rhs.m_dispatcher );
10744  }
10745 
10746  //=== VK_VERSION_1_2 ===
10747 
10748  VULKAN_HPP_NODISCARD uint64_t getCounterValue() const;
10749 
10750  //=== VK_KHR_timeline_semaphore ===
10751 
10752  VULKAN_HPP_NODISCARD uint64_t getCounterValueKHR() const;
10753 
10754  private:
10755  VULKAN_HPP_NAMESPACE::Device m_device = {};
10756  VULKAN_HPP_NAMESPACE::Semaphore m_semaphore = {};
10757  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
10758  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
10759  };
10760 
10762  {
10763  public:
10766 
10767  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eShaderEXT;
10769  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
10770 
10771  public:
10772 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
10773  ShaderEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
10774  VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT const & createInfo,
10775  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
10776  {
10777  *this = device.createShaderEXT( createInfo, allocator );
10778  }
10779 # endif
10780 
10781  ShaderEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
10782  VkShaderEXT shader,
10783  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
10784  : m_device( device )
10785  , m_shader( shader )
10786  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
10787  , m_dispatcher( device.getDispatcher() )
10788  {
10789  }
10790 
10791  ShaderEXT( std::nullptr_t ) {}
10792 
10794  {
10795  clear();
10796  }
10797 
10798  ShaderEXT() = delete;
10799  ShaderEXT( ShaderEXT const & ) = delete;
10800 
10802  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
10803  , m_shader( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_shader, {} ) )
10804  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
10805  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
10806  {
10807  }
10808 
10809  ShaderEXT & operator=( ShaderEXT const & ) = delete;
10810 
10812  {
10813  if ( this != &rhs )
10814  {
10815  std::swap( m_device, rhs.m_device );
10816  std::swap( m_shader, rhs.m_shader );
10817  std::swap( m_allocator, rhs.m_allocator );
10818  std::swap( m_dispatcher, rhs.m_dispatcher );
10819  }
10820  return *this;
10821  }
10822 
10823  VULKAN_HPP_NAMESPACE::ShaderEXT const & operator*() const VULKAN_HPP_NOEXCEPT
10824  {
10825  return m_shader;
10826  }
10827 
10828  operator VULKAN_HPP_NAMESPACE::ShaderEXT() const VULKAN_HPP_NOEXCEPT
10829  {
10830  return m_shader;
10831  }
10832 
10834  {
10835  if ( m_shader )
10836  {
10837  getDispatcher()->vkDestroyShaderEXT(
10838  static_cast<VkDevice>( m_device ), static_cast<VkShaderEXT>( m_shader ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
10839  }
10840  m_device = nullptr;
10841  m_shader = nullptr;
10842  m_allocator = nullptr;
10843  m_dispatcher = nullptr;
10844  }
10845 
10846  VULKAN_HPP_NAMESPACE::ShaderEXT release()
10847  {
10848  m_device = nullptr;
10849  m_allocator = nullptr;
10850  m_dispatcher = nullptr;
10852  }
10853 
10854  VULKAN_HPP_NAMESPACE::Device getDevice() const
10855  {
10856  return m_device;
10857  }
10858 
10859  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
10860  {
10861  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
10862  return m_dispatcher;
10863  }
10864 
10865  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ShaderEXT & rhs ) VULKAN_HPP_NOEXCEPT
10866  {
10867  std::swap( m_device, rhs.m_device );
10868  std::swap( m_shader, rhs.m_shader );
10869  std::swap( m_allocator, rhs.m_allocator );
10870  std::swap( m_dispatcher, rhs.m_dispatcher );
10871  }
10872 
10873  //=== VK_EXT_shader_object ===
10874 
10875  VULKAN_HPP_NODISCARD std::vector<uint8_t> getBinaryData() const;
10876 
10877  private:
10878  VULKAN_HPP_NAMESPACE::Device m_device = {};
10879  VULKAN_HPP_NAMESPACE::ShaderEXT m_shader = {};
10880  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
10881  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
10882  };
10883 
10884  class ShaderEXTs : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ShaderEXT>
10885  {
10886  public:
10887 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
10888  ShaderEXTs( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
10889  VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos,
10890  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
10891  {
10892  *this = device.createShadersEXT( createInfos, allocator );
10893  }
10894 # endif
10895 
10896  ShaderEXTs( std::nullptr_t ) {}
10897 
10898  ShaderEXTs() = delete;
10899  ShaderEXTs( ShaderEXTs const & ) = delete;
10900  ShaderEXTs( ShaderEXTs && rhs ) = default;
10901  ShaderEXTs & operator=( ShaderEXTs const & ) = delete;
10902  ShaderEXTs & operator=( ShaderEXTs && rhs ) = default;
10903 
10904  private:
10905  ShaderEXTs( std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ShaderEXT> && rhs )
10906  {
10907  std::swap( *this, rhs );
10908  }
10909  };
10910 
10912  {
10913  public:
10916 
10917  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eShaderModule;
10919  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eShaderModule;
10920 
10921  public:
10922 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
10923  ShaderModule( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
10924  VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo const & createInfo,
10925  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
10926  {
10927  *this = device.createShaderModule( createInfo, allocator );
10928  }
10929 # endif
10930 
10931  ShaderModule( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
10932  VkShaderModule shaderModule,
10933  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
10934  : m_device( device )
10935  , m_shaderModule( shaderModule )
10936  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
10937  , m_dispatcher( device.getDispatcher() )
10938  {
10939  }
10940 
10941  ShaderModule( std::nullptr_t ) {}
10942 
10944  {
10945  clear();
10946  }
10947 
10948  ShaderModule() = delete;
10949  ShaderModule( ShaderModule const & ) = delete;
10950 
10952  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
10953  , m_shaderModule( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_shaderModule, {} ) )
10954  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
10955  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
10956  {
10957  }
10958 
10959  ShaderModule & operator=( ShaderModule const & ) = delete;
10960 
10962  {
10963  if ( this != &rhs )
10964  {
10965  std::swap( m_device, rhs.m_device );
10966  std::swap( m_shaderModule, rhs.m_shaderModule );
10967  std::swap( m_allocator, rhs.m_allocator );
10968  std::swap( m_dispatcher, rhs.m_dispatcher );
10969  }
10970  return *this;
10971  }
10972 
10973  VULKAN_HPP_NAMESPACE::ShaderModule const & operator*() const VULKAN_HPP_NOEXCEPT
10974  {
10975  return m_shaderModule;
10976  }
10977 
10978  operator VULKAN_HPP_NAMESPACE::ShaderModule() const VULKAN_HPP_NOEXCEPT
10979  {
10980  return m_shaderModule;
10981  }
10982 
10984  {
10985  if ( m_shaderModule )
10986  {
10987  getDispatcher()->vkDestroyShaderModule(
10988  static_cast<VkDevice>( m_device ), static_cast<VkShaderModule>( m_shaderModule ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
10989  }
10990  m_device = nullptr;
10991  m_shaderModule = nullptr;
10992  m_allocator = nullptr;
10993  m_dispatcher = nullptr;
10994  }
10995 
10996  VULKAN_HPP_NAMESPACE::ShaderModule release()
10997  {
10998  m_device = nullptr;
10999  m_allocator = nullptr;
11000  m_dispatcher = nullptr;
11001  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_shaderModule, nullptr );
11002  }
11003 
11004  VULKAN_HPP_NAMESPACE::Device getDevice() const
11005  {
11006  return m_device;
11007  }
11008 
11009  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
11010  {
11011  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
11012  return m_dispatcher;
11013  }
11014 
11015  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ShaderModule & rhs ) VULKAN_HPP_NOEXCEPT
11016  {
11017  std::swap( m_device, rhs.m_device );
11018  std::swap( m_shaderModule, rhs.m_shaderModule );
11019  std::swap( m_allocator, rhs.m_allocator );
11020  std::swap( m_dispatcher, rhs.m_dispatcher );
11021  }
11022 
11023  //=== VK_EXT_shader_module_identifier ===
11024 
11025  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT getIdentifierEXT() const VULKAN_HPP_NOEXCEPT;
11026 
11027  private:
11028  VULKAN_HPP_NAMESPACE::Device m_device = {};
11029  VULKAN_HPP_NAMESPACE::ShaderModule m_shaderModule = {};
11030  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
11031  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
11032  };
11033 
11035  {
11036  public:
11039 
11040  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSurfaceKHR;
11042  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSurfaceKHR;
11043 
11044  public:
11045 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
11046 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
11047  SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,
11048  VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR const & createInfo,
11049  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
11050  {
11051  *this = instance.createAndroidSurfaceKHR( createInfo, allocator );
11052  }
11053 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
11054 # endif
11055 
11056 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
11057 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
11058  SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,
11059  VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT const & createInfo,
11060  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
11061  {
11062  *this = instance.createDirectFBSurfaceEXT( createInfo, allocator );
11063  }
11064 # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
11065 # endif
11066 
11067 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
11068  SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,
11069  VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR const & createInfo,
11070  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
11071  {
11072  *this = instance.createDisplayPlaneSurfaceKHR( createInfo, allocator );
11073  }
11074 # endif
11075 
11076 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
11077  SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,
11078  VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT const & createInfo,
11079  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
11080  {
11081  *this = instance.createHeadlessSurfaceEXT( createInfo, allocator );
11082  }
11083 # endif
11084 
11085 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
11086 # if defined( VK_USE_PLATFORM_IOS_MVK )
11087  SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,
11088  VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK const & createInfo,
11089  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
11090  {
11091  *this = instance.createIOSSurfaceMVK( createInfo, allocator );
11092  }
11093 # endif /*VK_USE_PLATFORM_IOS_MVK*/
11094 # endif
11095 
11096 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
11097 # if defined( VK_USE_PLATFORM_FUCHSIA )
11098  SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,
11099  VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA const & createInfo,
11100  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
11101  {
11102  *this = instance.createImagePipeSurfaceFUCHSIA( createInfo, allocator );
11103  }
11104 # endif /*VK_USE_PLATFORM_FUCHSIA*/
11105 # endif
11106 
11107 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
11108 # if defined( VK_USE_PLATFORM_MACOS_MVK )
11109  SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,
11110  VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK const & createInfo,
11111  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
11112  {
11113  *this = instance.createMacOSSurfaceMVK( createInfo, allocator );
11114  }
11115 # endif /*VK_USE_PLATFORM_MACOS_MVK*/
11116 # endif
11117 
11118 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
11119 # if defined( VK_USE_PLATFORM_METAL_EXT )
11120  SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,
11121  VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT const & createInfo,
11122  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
11123  {
11124  *this = instance.createMetalSurfaceEXT( createInfo, allocator );
11125  }
11126 # endif /*VK_USE_PLATFORM_METAL_EXT*/
11127 # endif
11128 
11129 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
11130 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
11131  SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,
11132  VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const & createInfo,
11133  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
11134  {
11135  *this = instance.createScreenSurfaceQNX( createInfo, allocator );
11136  }
11137 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/
11138 # endif
11139 
11140 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
11141 # if defined( VK_USE_PLATFORM_GGP )
11142  SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,
11143  VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP const & createInfo,
11144  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
11145  {
11146  *this = instance.createStreamDescriptorSurfaceGGP( createInfo, allocator );
11147  }
11148 # endif /*VK_USE_PLATFORM_GGP*/
11149 # endif
11150 
11151 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
11152 # if defined( VK_USE_PLATFORM_VI_NN )
11153  SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,
11154  VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN const & createInfo,
11155  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
11156  {
11157  *this = instance.createViSurfaceNN( createInfo, allocator );
11158  }
11159 # endif /*VK_USE_PLATFORM_VI_NN*/
11160 # endif
11161 
11162 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
11163 # if defined( VK_USE_PLATFORM_WAYLAND_KHR )
11164  SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,
11165  VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR const & createInfo,
11166  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
11167  {
11168  *this = instance.createWaylandSurfaceKHR( createInfo, allocator );
11169  }
11170 # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
11171 # endif
11172 
11173 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
11174 # if defined( VK_USE_PLATFORM_WIN32_KHR )
11175  SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,
11176  VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR const & createInfo,
11177  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
11178  {
11179  *this = instance.createWin32SurfaceKHR( createInfo, allocator );
11180  }
11181 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
11182 # endif
11183 
11184 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
11185 # if defined( VK_USE_PLATFORM_XCB_KHR )
11186  SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,
11187  VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR const & createInfo,
11188  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
11189  {
11190  *this = instance.createXcbSurfaceKHR( createInfo, allocator );
11191  }
11192 # endif /*VK_USE_PLATFORM_XCB_KHR*/
11193 # endif
11194 
11195 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
11196 # if defined( VK_USE_PLATFORM_XLIB_KHR )
11197  SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,
11198  VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR const & createInfo,
11199  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
11200  {
11201  *this = instance.createXlibSurfaceKHR( createInfo, allocator );
11202  }
11203 # endif /*VK_USE_PLATFORM_XLIB_KHR*/
11204 # endif
11205 
11206  SurfaceKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance const & instance,
11207  VkSurfaceKHR surface,
11208  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
11209  : m_instance( instance )
11210  , m_surface( surface )
11211  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
11212  , m_dispatcher( instance.getDispatcher() )
11213  {
11214  }
11215 
11216  SurfaceKHR( std::nullptr_t ) {}
11217 
11219  {
11220  clear();
11221  }
11222 
11223  SurfaceKHR() = delete;
11224  SurfaceKHR( SurfaceKHR const & ) = delete;
11225 
11227  : m_instance( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_instance, {} ) )
11228  , m_surface( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_surface, {} ) )
11229  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
11230  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
11231  {
11232  }
11233 
11234  SurfaceKHR & operator=( SurfaceKHR const & ) = delete;
11235 
11237  {
11238  if ( this != &rhs )
11239  {
11240  std::swap( m_instance, rhs.m_instance );
11241  std::swap( m_surface, rhs.m_surface );
11242  std::swap( m_allocator, rhs.m_allocator );
11243  std::swap( m_dispatcher, rhs.m_dispatcher );
11244  }
11245  return *this;
11246  }
11247 
11248  VULKAN_HPP_NAMESPACE::SurfaceKHR const & operator*() const VULKAN_HPP_NOEXCEPT
11249  {
11250  return m_surface;
11251  }
11252 
11253  operator VULKAN_HPP_NAMESPACE::SurfaceKHR() const VULKAN_HPP_NOEXCEPT
11254  {
11255  return m_surface;
11256  }
11257 
11259  {
11260  if ( m_surface )
11261  {
11262  getDispatcher()->vkDestroySurfaceKHR(
11263  static_cast<VkInstance>( m_instance ), static_cast<VkSurfaceKHR>( m_surface ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
11264  }
11265  m_instance = nullptr;
11266  m_surface = nullptr;
11267  m_allocator = nullptr;
11268  m_dispatcher = nullptr;
11269  }
11270 
11271  VULKAN_HPP_NAMESPACE::SurfaceKHR release()
11272  {
11273  m_instance = nullptr;
11274  m_allocator = nullptr;
11275  m_dispatcher = nullptr;
11276  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_surface, nullptr );
11277  }
11278 
11279  VULKAN_HPP_NAMESPACE::Instance getInstance() const
11280  {
11281  return m_instance;
11282  }
11283 
11284  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * getDispatcher() const
11285  {
11286  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
11287  return m_dispatcher;
11288  }
11289 
11290  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR & rhs ) VULKAN_HPP_NOEXCEPT
11291  {
11292  std::swap( m_instance, rhs.m_instance );
11293  std::swap( m_surface, rhs.m_surface );
11294  std::swap( m_allocator, rhs.m_allocator );
11295  std::swap( m_dispatcher, rhs.m_dispatcher );
11296  }
11297 
11298  private:
11299  VULKAN_HPP_NAMESPACE::Instance m_instance = {};
11300  VULKAN_HPP_NAMESPACE::SurfaceKHR m_surface = {};
11301  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
11302  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::InstanceDispatcher const * m_dispatcher = nullptr;
11303  };
11304 
11306  {
11307  public:
11310 
11311  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eSwapchainKHR;
11313  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eSwapchainKHR;
11314 
11315  public:
11316 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
11317  SwapchainKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
11318  VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & createInfo,
11319  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
11320  {
11321  *this = device.createSwapchainKHR( createInfo, allocator );
11322  }
11323 # endif
11324 
11325  SwapchainKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
11326  VkSwapchainKHR swapchain,
11327  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
11328  : m_device( device )
11329  , m_swapchain( swapchain )
11330  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
11331  , m_dispatcher( device.getDispatcher() )
11332  {
11333  }
11334 
11335  SwapchainKHR( std::nullptr_t ) {}
11336 
11338  {
11339  clear();
11340  }
11341 
11342  SwapchainKHR() = delete;
11343  SwapchainKHR( SwapchainKHR const & ) = delete;
11344 
11346  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
11347  , m_swapchain( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_swapchain, {} ) )
11348  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
11349  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
11350  {
11351  }
11352 
11353  SwapchainKHR & operator=( SwapchainKHR const & ) = delete;
11354 
11356  {
11357  if ( this != &rhs )
11358  {
11359  std::swap( m_device, rhs.m_device );
11360  std::swap( m_swapchain, rhs.m_swapchain );
11361  std::swap( m_allocator, rhs.m_allocator );
11362  std::swap( m_dispatcher, rhs.m_dispatcher );
11363  }
11364  return *this;
11365  }
11366 
11367  VULKAN_HPP_NAMESPACE::SwapchainKHR const & operator*() const VULKAN_HPP_NOEXCEPT
11368  {
11369  return m_swapchain;
11370  }
11371 
11372  operator VULKAN_HPP_NAMESPACE::SwapchainKHR() const VULKAN_HPP_NOEXCEPT
11373  {
11374  return m_swapchain;
11375  }
11376 
11378  {
11379  if ( m_swapchain )
11380  {
11381  getDispatcher()->vkDestroySwapchainKHR(
11382  static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
11383  }
11384  m_device = nullptr;
11385  m_swapchain = nullptr;
11386  m_allocator = nullptr;
11387  m_dispatcher = nullptr;
11388  }
11389 
11390  VULKAN_HPP_NAMESPACE::SwapchainKHR release()
11391  {
11392  m_device = nullptr;
11393  m_allocator = nullptr;
11394  m_dispatcher = nullptr;
11395  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_swapchain, nullptr );
11396  }
11397 
11398  VULKAN_HPP_NAMESPACE::Device getDevice() const
11399  {
11400  return m_device;
11401  }
11402 
11403  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
11404  {
11405  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
11406  return m_dispatcher;
11407  }
11408 
11409  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR & rhs ) VULKAN_HPP_NOEXCEPT
11410  {
11411  std::swap( m_device, rhs.m_device );
11412  std::swap( m_swapchain, rhs.m_swapchain );
11413  std::swap( m_allocator, rhs.m_allocator );
11414  std::swap( m_dispatcher, rhs.m_dispatcher );
11415  }
11416 
11417  //=== VK_KHR_swapchain ===
11418 
11419  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::Image> getImages() const;
11420 
11421  VULKAN_HPP_NODISCARD std::pair<VULKAN_HPP_NAMESPACE::Result, uint32_t>
11422  acquireNextImage( uint64_t timeout,
11423  VULKAN_HPP_NAMESPACE::Semaphore semaphore VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
11424  VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT ) const;
11425 
11426  //=== VK_EXT_display_control ===
11427 
11428  VULKAN_HPP_NODISCARD uint64_t getCounterEXT( VULKAN_HPP_NAMESPACE::SurfaceCounterFlagBitsEXT counter ) const;
11429 
11430  //=== VK_GOOGLE_display_timing ===
11431 
11432  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE getRefreshCycleDurationGOOGLE() const;
11433 
11434  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE> getPastPresentationTimingGOOGLE() const;
11435 
11436  //=== VK_KHR_shared_presentable_image ===
11437 
11439 
11440  //=== VK_AMD_display_native_hdr ===
11441 
11442  void setLocalDimmingAMD( VULKAN_HPP_NAMESPACE::Bool32 localDimmingEnable ) const VULKAN_HPP_NOEXCEPT;
11443 
11444  //=== VK_KHR_present_wait ===
11445 
11446  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result waitForPresent( uint64_t presentId, uint64_t timeout ) const;
11447 
11448 # if defined( VK_USE_PLATFORM_WIN32_KHR )
11449  //=== VK_EXT_full_screen_exclusive ===
11450 
11451  void acquireFullScreenExclusiveModeEXT() const;
11452 
11453  void releaseFullScreenExclusiveModeEXT() const;
11454 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
11455 
11456  //=== VK_NV_low_latency2 ===
11457 
11458  void setLatencySleepModeNV( const VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV & sleepModeInfo ) const;
11459 
11460  void latencySleepNV( const VULKAN_HPP_NAMESPACE::LatencySleepInfoNV & sleepInfo ) const;
11461 
11462  void setLatencyMarkerNV( const VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV & latencyMarkerInfo ) const VULKAN_HPP_NOEXCEPT;
11463 
11464  VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV getLatencyTimingsNV() const VULKAN_HPP_NOEXCEPT;
11465 
11466  private:
11467  VULKAN_HPP_NAMESPACE::Device m_device = {};
11468  VULKAN_HPP_NAMESPACE::SwapchainKHR m_swapchain = {};
11469  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
11470  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
11471  };
11472 
11473  class SwapchainKHRs : public std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR>
11474  {
11475  public:
11476 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
11477  SwapchainKHRs( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
11478  VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
11479  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
11480  {
11481  *this = device.createSharedSwapchainsKHR( createInfos, allocator );
11482  }
11483 # endif
11484 
11485  SwapchainKHRs( std::nullptr_t ) {}
11486 
11487  SwapchainKHRs() = delete;
11488  SwapchainKHRs( SwapchainKHRs const & ) = delete;
11489  SwapchainKHRs( SwapchainKHRs && rhs ) = default;
11490  SwapchainKHRs & operator=( SwapchainKHRs const & ) = delete;
11491  SwapchainKHRs & operator=( SwapchainKHRs && rhs ) = default;
11492 
11493  private:
11494  SwapchainKHRs( std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR> && rhs )
11495  {
11496  std::swap( *this, rhs );
11497  }
11498  };
11499 
11501  {
11502  public:
11505 
11506  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eValidationCacheEXT;
11508  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eValidationCacheEXT;
11509 
11510  public:
11511 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
11512  ValidationCacheEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
11513  VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT const & createInfo,
11514  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
11515  {
11516  *this = device.createValidationCacheEXT( createInfo, allocator );
11517  }
11518 # endif
11519 
11520  ValidationCacheEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
11521  VkValidationCacheEXT validationCache,
11522  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
11523  : m_device( device )
11524  , m_validationCache( validationCache )
11525  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
11526  , m_dispatcher( device.getDispatcher() )
11527  {
11528  }
11529 
11530  ValidationCacheEXT( std::nullptr_t ) {}
11531 
11533  {
11534  clear();
11535  }
11536 
11539 
11541  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
11542  , m_validationCache( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_validationCache, {} ) )
11543  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
11544  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
11545  {
11546  }
11547 
11549 
11551  {
11552  if ( this != &rhs )
11553  {
11554  std::swap( m_device, rhs.m_device );
11555  std::swap( m_validationCache, rhs.m_validationCache );
11556  std::swap( m_allocator, rhs.m_allocator );
11557  std::swap( m_dispatcher, rhs.m_dispatcher );
11558  }
11559  return *this;
11560  }
11561 
11562  VULKAN_HPP_NAMESPACE::ValidationCacheEXT const & operator*() const VULKAN_HPP_NOEXCEPT
11563  {
11564  return m_validationCache;
11565  }
11566 
11567  operator VULKAN_HPP_NAMESPACE::ValidationCacheEXT() const VULKAN_HPP_NOEXCEPT
11568  {
11569  return m_validationCache;
11570  }
11571 
11573  {
11574  if ( m_validationCache )
11575  {
11576  getDispatcher()->vkDestroyValidationCacheEXT( static_cast<VkDevice>( m_device ),
11577  static_cast<VkValidationCacheEXT>( m_validationCache ),
11578  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
11579  }
11580  m_device = nullptr;
11581  m_validationCache = nullptr;
11582  m_allocator = nullptr;
11583  m_dispatcher = nullptr;
11584  }
11585 
11586  VULKAN_HPP_NAMESPACE::ValidationCacheEXT release()
11587  {
11588  m_device = nullptr;
11589  m_allocator = nullptr;
11590  m_dispatcher = nullptr;
11591  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_validationCache, nullptr );
11592  }
11593 
11594  VULKAN_HPP_NAMESPACE::Device getDevice() const
11595  {
11596  return m_device;
11597  }
11598 
11599  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
11600  {
11601  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
11602  return m_dispatcher;
11603  }
11604 
11605  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ValidationCacheEXT & rhs ) VULKAN_HPP_NOEXCEPT
11606  {
11607  std::swap( m_device, rhs.m_device );
11608  std::swap( m_validationCache, rhs.m_validationCache );
11609  std::swap( m_allocator, rhs.m_allocator );
11610  std::swap( m_dispatcher, rhs.m_dispatcher );
11611  }
11612 
11613  //=== VK_EXT_validation_cache ===
11614 
11615  void merge( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ValidationCacheEXT> const & srcCaches ) const;
11616 
11617  VULKAN_HPP_NODISCARD std::vector<uint8_t> getData() const;
11618 
11619  private:
11620  VULKAN_HPP_NAMESPACE::Device m_device = {};
11621  VULKAN_HPP_NAMESPACE::ValidationCacheEXT m_validationCache = {};
11622  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
11623  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
11624  };
11625 
11627  {
11628  public:
11631 
11632  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionKHR;
11634  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
11635 
11636  public:
11637 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
11638  VideoSessionKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
11639  VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const & createInfo,
11640  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
11641  {
11642  *this = device.createVideoSessionKHR( createInfo, allocator );
11643  }
11644 # endif
11645 
11646  VideoSessionKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
11647  VkVideoSessionKHR videoSession,
11648  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
11649  : m_device( device )
11650  , m_videoSession( videoSession )
11651  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
11652  , m_dispatcher( device.getDispatcher() )
11653  {
11654  }
11655 
11656  VideoSessionKHR( std::nullptr_t ) {}
11657 
11659  {
11660  clear();
11661  }
11662 
11663  VideoSessionKHR() = delete;
11664  VideoSessionKHR( VideoSessionKHR const & ) = delete;
11665 
11667  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
11668  , m_videoSession( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_videoSession, {} ) )
11669  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
11670  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
11671  {
11672  }
11673 
11675 
11677  {
11678  if ( this != &rhs )
11679  {
11680  std::swap( m_device, rhs.m_device );
11681  std::swap( m_videoSession, rhs.m_videoSession );
11682  std::swap( m_allocator, rhs.m_allocator );
11683  std::swap( m_dispatcher, rhs.m_dispatcher );
11684  }
11685  return *this;
11686  }
11687 
11688  VULKAN_HPP_NAMESPACE::VideoSessionKHR const & operator*() const VULKAN_HPP_NOEXCEPT
11689  {
11690  return m_videoSession;
11691  }
11692 
11693  operator VULKAN_HPP_NAMESPACE::VideoSessionKHR() const VULKAN_HPP_NOEXCEPT
11694  {
11695  return m_videoSession;
11696  }
11697 
11699  {
11700  if ( m_videoSession )
11701  {
11702  getDispatcher()->vkDestroyVideoSessionKHR( static_cast<VkDevice>( m_device ),
11703  static_cast<VkVideoSessionKHR>( m_videoSession ),
11704  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
11705  }
11706  m_device = nullptr;
11707  m_videoSession = nullptr;
11708  m_allocator = nullptr;
11709  m_dispatcher = nullptr;
11710  }
11711 
11712  VULKAN_HPP_NAMESPACE::VideoSessionKHR release()
11713  {
11714  m_device = nullptr;
11715  m_allocator = nullptr;
11716  m_dispatcher = nullptr;
11717  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_videoSession, nullptr );
11718  }
11719 
11720  VULKAN_HPP_NAMESPACE::Device getDevice() const
11721  {
11722  return m_device;
11723  }
11724 
11725  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
11726  {
11727  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
11728  return m_dispatcher;
11729  }
11730 
11731  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::VideoSessionKHR & rhs ) VULKAN_HPP_NOEXCEPT
11732  {
11733  std::swap( m_device, rhs.m_device );
11734  std::swap( m_videoSession, rhs.m_videoSession );
11735  std::swap( m_allocator, rhs.m_allocator );
11736  std::swap( m_dispatcher, rhs.m_dispatcher );
11737  }
11738 
11739  //=== VK_KHR_video_queue ===
11740 
11741  VULKAN_HPP_NODISCARD std::vector<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR> getMemoryRequirements() const;
11742 
11743  void bindMemory( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR> const & bindSessionMemoryInfos ) const;
11744 
11745  private:
11746  VULKAN_HPP_NAMESPACE::Device m_device = {};
11747  VULKAN_HPP_NAMESPACE::VideoSessionKHR m_videoSession = {};
11748  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
11749  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
11750  };
11751 
11753  {
11754  public:
11757 
11758  static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eVideoSessionParametersKHR;
11760  VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown;
11761 
11762  public:
11763 # if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
11764  VideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
11765  VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR const & createInfo,
11766  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
11767  {
11768  *this = device.createVideoSessionParametersKHR( createInfo, allocator );
11769  }
11770 # endif
11771 
11772  VideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device,
11773  VkVideoSessionParametersKHR videoSessionParameters,
11774  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator = nullptr )
11775  : m_device( device )
11776  , m_videoSessionParameters( videoSessionParameters )
11777  , m_allocator( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) )
11778  , m_dispatcher( device.getDispatcher() )
11779  {
11780  }
11781 
11782  VideoSessionParametersKHR( std::nullptr_t ) {}
11783 
11785  {
11786  clear();
11787  }
11788 
11791 
11793  : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) )
11794  , m_videoSessionParameters( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_videoSessionParameters, {} ) )
11795  , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) )
11796  , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) )
11797  {
11798  }
11799 
11801 
11803  {
11804  if ( this != &rhs )
11805  {
11806  std::swap( m_device, rhs.m_device );
11807  std::swap( m_videoSessionParameters, rhs.m_videoSessionParameters );
11808  std::swap( m_allocator, rhs.m_allocator );
11809  std::swap( m_dispatcher, rhs.m_dispatcher );
11810  }
11811  return *this;
11812  }
11813 
11814  VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR const & operator*() const VULKAN_HPP_NOEXCEPT
11815  {
11816  return m_videoSessionParameters;
11817  }
11818 
11819  operator VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR() const VULKAN_HPP_NOEXCEPT
11820  {
11821  return m_videoSessionParameters;
11822  }
11823 
11825  {
11826  if ( m_videoSessionParameters )
11827  {
11828  getDispatcher()->vkDestroyVideoSessionParametersKHR( static_cast<VkDevice>( m_device ),
11829  static_cast<VkVideoSessionParametersKHR>( m_videoSessionParameters ),
11830  reinterpret_cast<const VkAllocationCallbacks *>( m_allocator ) );
11831  }
11832  m_device = nullptr;
11833  m_videoSessionParameters = nullptr;
11834  m_allocator = nullptr;
11835  m_dispatcher = nullptr;
11836  }
11837 
11838  VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR release()
11839  {
11840  m_device = nullptr;
11841  m_allocator = nullptr;
11842  m_dispatcher = nullptr;
11843  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_videoSessionParameters, nullptr );
11844  }
11845 
11846  VULKAN_HPP_NAMESPACE::Device getDevice() const
11847  {
11848  return m_device;
11849  }
11850 
11851  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * getDispatcher() const
11852  {
11853  VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION );
11854  return m_dispatcher;
11855  }
11856 
11857  void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::VideoSessionParametersKHR & rhs ) VULKAN_HPP_NOEXCEPT
11858  {
11859  std::swap( m_device, rhs.m_device );
11860  std::swap( m_videoSessionParameters, rhs.m_videoSessionParameters );
11861  std::swap( m_allocator, rhs.m_allocator );
11862  std::swap( m_dispatcher, rhs.m_dispatcher );
11863  }
11864 
11865  //=== VK_KHR_video_queue ===
11866 
11867  void update( const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR & updateInfo ) const;
11868 
11869  private:
11870  VULKAN_HPP_NAMESPACE::Device m_device = {};
11871  VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR m_videoSessionParameters = {};
11872  const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {};
11873  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr;
11874  };
11875 
11876  //===========================
11877  //=== COMMAND Definitions ===
11878  //===========================
11879 
11880  //=== VK_VERSION_1_0 ===
11881 
11883  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance>::Type
11884  Context::createInstance( VULKAN_HPP_NAMESPACE::InstanceCreateInfo const & createInfo,
11885  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT
11886  {
11887  VULKAN_HPP_NAMESPACE::Instance instance;
11888  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateInstance(
11889  reinterpret_cast<const VkInstanceCreateInfo *>( &createInfo ),
11890  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
11891  reinterpret_cast<VkInstance *>( &instance ) ) );
11892  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
11893  {
11894 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
11895  return VULKAN_HPP_UNEXPECTED( result );
11896 # else
11897  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Context::createInstance" );
11898 # endif
11899  }
11900 
11901  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Instance( *this, *reinterpret_cast<VkInstance *>( &instance ), allocator );
11902  }
11903 
11905  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice>>::Type
11906  Instance::enumeratePhysicalDevices() const
11907  {
11908  std::vector<VULKAN_HPP_NAMESPACE::PhysicalDevice> physicalDevices;
11909  uint32_t physicalDeviceCount;
11911  do
11912  {
11913  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
11914  getDispatcher()->vkEnumeratePhysicalDevices( static_cast<VkInstance>( m_instance ), &physicalDeviceCount, nullptr ) );
11915  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && physicalDeviceCount )
11916  {
11917  physicalDevices.resize( physicalDeviceCount );
11918  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumeratePhysicalDevices(
11919  static_cast<VkInstance>( m_instance ), &physicalDeviceCount, reinterpret_cast<VkPhysicalDevice *>( physicalDevices.data() ) ) );
11920  }
11921  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
11922  if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( result != VULKAN_HPP_NAMESPACE::Result::eIncomplete ) )
11923  {
11924 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
11925  return VULKAN_HPP_UNEXPECTED( result );
11926 # else
11927  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Instance::enumeratePhysicalDevices" );
11928 # endif
11929  }
11930 
11931  std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice> physicalDevicesRAII;
11932  physicalDevicesRAII.reserve( physicalDevices.size() );
11933  for ( auto & physicalDevice : physicalDevices )
11934  {
11935  physicalDevicesRAII.emplace_back( *this, *reinterpret_cast<VkPhysicalDevice *>( &physicalDevice ) );
11936  }
11937  return physicalDevicesRAII;
11938  }
11939 
11940  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures PhysicalDevice::getFeatures() const VULKAN_HPP_NOEXCEPT
11941  {
11942  VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFeatures && "Function <vkGetPhysicalDeviceFeatures> requires <VK_VERSION_1_0>" );
11943 
11944  VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures features;
11945  getDispatcher()->vkGetPhysicalDeviceFeatures( static_cast<VkPhysicalDevice>( m_physicalDevice ),
11946  reinterpret_cast<VkPhysicalDeviceFeatures *>( &features ) );
11947 
11948  return features;
11949  }
11950 
11951  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::FormatProperties
11952  PhysicalDevice::getFormatProperties( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT
11953  {
11954  VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFormatProperties && "Function <vkGetPhysicalDeviceFormatProperties> requires <VK_VERSION_1_0>" );
11955 
11956  VULKAN_HPP_NAMESPACE::FormatProperties formatProperties;
11957  getDispatcher()->vkGetPhysicalDeviceFormatProperties(
11958  static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties *>( &formatProperties ) );
11959 
11960  return formatProperties;
11961  }
11962 
11963  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ImageFormatProperties
11964  PhysicalDevice::getImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format,
11969  {
11971  "Function <vkGetPhysicalDeviceImageFormatProperties> requires <VK_VERSION_1_0>" );
11972 
11973  VULKAN_HPP_NAMESPACE::ImageFormatProperties imageFormatProperties;
11975  getDispatcher()->vkGetPhysicalDeviceImageFormatProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ),
11976  static_cast<VkFormat>( format ),
11977  static_cast<VkImageType>( type ),
11978  static_cast<VkImageTiling>( tiling ),
11979  static_cast<VkImageUsageFlags>( usage ),
11980  static_cast<VkImageCreateFlags>( flags ),
11981  reinterpret_cast<VkImageFormatProperties *>( &imageFormatProperties ) ) );
11982  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties" );
11983 
11984  return imageFormatProperties;
11985  }
11986 
11987  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties PhysicalDevice::getProperties() const VULKAN_HPP_NOEXCEPT
11988  {
11989  VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceProperties && "Function <vkGetPhysicalDeviceProperties> requires <VK_VERSION_1_0>" );
11990 
11991  VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties properties;
11992  getDispatcher()->vkGetPhysicalDeviceProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ),
11993  reinterpret_cast<VkPhysicalDeviceProperties *>( &properties ) );
11994 
11995  return properties;
11996  }
11997 
11998  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties> PhysicalDevice::getQueueFamilyProperties() const
11999  {
12001  "Function <vkGetPhysicalDeviceQueueFamilyProperties> requires <VK_VERSION_1_0>" );
12002 
12003  std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties> queueFamilyProperties;
12004  uint32_t queueFamilyPropertyCount;
12005  getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ), &queueFamilyPropertyCount, nullptr );
12006  queueFamilyProperties.resize( queueFamilyPropertyCount );
12007  getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ),
12008  &queueFamilyPropertyCount,
12009  reinterpret_cast<VkQueueFamilyProperties *>( queueFamilyProperties.data() ) );
12010 
12011  VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
12012  if ( queueFamilyPropertyCount < queueFamilyProperties.size() )
12013  {
12014  queueFamilyProperties.resize( queueFamilyPropertyCount );
12015  }
12016  return queueFamilyProperties;
12017  }
12018 
12019  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties PhysicalDevice::getMemoryProperties() const VULKAN_HPP_NOEXCEPT
12020  {
12021  VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceMemoryProperties && "Function <vkGetPhysicalDeviceMemoryProperties> requires <VK_VERSION_1_0>" );
12022 
12023  VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties memoryProperties;
12024  getDispatcher()->vkGetPhysicalDeviceMemoryProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ),
12025  reinterpret_cast<VkPhysicalDeviceMemoryProperties *>( &memoryProperties ) );
12026 
12027  return memoryProperties;
12028  }
12029 
12030  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PFN_vkVoidFunction Instance::getProcAddr( const std::string & name ) const VULKAN_HPP_NOEXCEPT
12031  {
12032  VULKAN_HPP_ASSERT( getDispatcher()->vkGetInstanceProcAddr && "Function <vkGetInstanceProcAddr> requires <VK_VERSION_1_0>" );
12033 
12034  PFN_vkVoidFunction result = getDispatcher()->vkGetInstanceProcAddr( static_cast<VkInstance>( m_instance ), name.c_str() );
12035 
12036  return result;
12037  }
12038 
12039  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PFN_vkVoidFunction Device::getProcAddr( const std::string & name ) const VULKAN_HPP_NOEXCEPT
12040  {
12041  VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceProcAddr && "Function <vkGetDeviceProcAddr> requires <VK_VERSION_1_0>" );
12042 
12043  PFN_vkVoidFunction result = getDispatcher()->vkGetDeviceProcAddr( static_cast<VkDevice>( m_device ), name.c_str() );
12044 
12045  return result;
12046  }
12047 
12049  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device>::Type
12050  PhysicalDevice::createDevice( VULKAN_HPP_NAMESPACE::DeviceCreateInfo const & createInfo,
12051  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
12053  {
12054  VULKAN_HPP_NAMESPACE::Device device;
12055  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateDevice(
12056  static_cast<VkPhysicalDevice>( m_physicalDevice ),
12057  reinterpret_cast<const VkDeviceCreateInfo *>( &createInfo ),
12058  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
12059  reinterpret_cast<VkDevice *>( &device ) ) );
12060  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
12061  {
12062 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
12063  return VULKAN_HPP_UNEXPECTED( result );
12064 # else
12065  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "PhysicalDevice::createDevice" );
12066 # endif
12067  }
12068 
12069  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device( *this, *reinterpret_cast<VkDevice *>( &device ), allocator );
12070  }
12071 
12072  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties>
12074  {
12076  "Function <vkEnumerateInstanceExtensionProperties> requires <VK_VERSION_1_0>" );
12077 
12078  std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties> properties;
12079  uint32_t propertyCount;
12081  do
12082  {
12083  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
12084  getDispatcher()->vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) );
12085  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount )
12086  {
12087  properties.resize( propertyCount );
12088  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumerateInstanceExtensionProperties(
12089  layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast<VkExtensionProperties *>( properties.data() ) ) );
12090  }
12091  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
12092  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Context::enumerateInstanceExtensionProperties" );
12093  VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
12094  if ( propertyCount < properties.size() )
12095  {
12096  properties.resize( propertyCount );
12097  }
12098  return properties;
12099  }
12100 
12101  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties>
12102  PhysicalDevice::enumerateDeviceExtensionProperties( Optional<const std::string> layerName ) const
12103  {
12104  VULKAN_HPP_ASSERT( getDispatcher()->vkEnumerateDeviceExtensionProperties && "Function <vkEnumerateDeviceExtensionProperties> requires <VK_VERSION_1_0>" );
12105 
12106  std::vector<VULKAN_HPP_NAMESPACE::ExtensionProperties> properties;
12107  uint32_t propertyCount;
12109  do
12110  {
12111  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumerateDeviceExtensionProperties(
12112  static_cast<VkPhysicalDevice>( m_physicalDevice ), layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) );
12113  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount )
12114  {
12115  properties.resize( propertyCount );
12116  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
12117  getDispatcher()->vkEnumerateDeviceExtensionProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ),
12118  layerName ? layerName->c_str() : nullptr,
12119  &propertyCount,
12120  reinterpret_cast<VkExtensionProperties *>( properties.data() ) ) );
12121  }
12122  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
12123  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceExtensionProperties" );
12124  VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
12125  if ( propertyCount < properties.size() )
12126  {
12127  properties.resize( propertyCount );
12128  }
12129  return properties;
12130  }
12131 
12132  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::LayerProperties> Context::enumerateInstanceLayerProperties() const
12133  {
12134  VULKAN_HPP_ASSERT( getDispatcher()->vkEnumerateInstanceLayerProperties && "Function <vkEnumerateInstanceLayerProperties> requires <VK_VERSION_1_0>" );
12135 
12136  std::vector<VULKAN_HPP_NAMESPACE::LayerProperties> properties;
12137  uint32_t propertyCount;
12139  do
12140  {
12141  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumerateInstanceLayerProperties( &propertyCount, nullptr ) );
12142  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount )
12143  {
12144  properties.resize( propertyCount );
12145  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
12146  getDispatcher()->vkEnumerateInstanceLayerProperties( &propertyCount, reinterpret_cast<VkLayerProperties *>( properties.data() ) ) );
12147  }
12148  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
12149  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Context::enumerateInstanceLayerProperties" );
12150  VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
12151  if ( propertyCount < properties.size() )
12152  {
12153  properties.resize( propertyCount );
12154  }
12155  return properties;
12156  }
12157 
12158  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::LayerProperties> PhysicalDevice::enumerateDeviceLayerProperties() const
12159  {
12160  VULKAN_HPP_ASSERT( getDispatcher()->vkEnumerateDeviceLayerProperties && "Function <vkEnumerateDeviceLayerProperties> requires <VK_VERSION_1_0>" );
12161 
12162  std::vector<VULKAN_HPP_NAMESPACE::LayerProperties> properties;
12163  uint32_t propertyCount;
12165  do
12166  {
12167  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
12168  getDispatcher()->vkEnumerateDeviceLayerProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, nullptr ) );
12169  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount )
12170  {
12171  properties.resize( propertyCount );
12172  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumerateDeviceLayerProperties(
12173  static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, reinterpret_cast<VkLayerProperties *>( properties.data() ) ) );
12174  }
12175  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
12176  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceLayerProperties" );
12177  VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
12178  if ( propertyCount < properties.size() )
12179  {
12180  properties.resize( propertyCount );
12181  }
12182  return properties;
12183  }
12184 
12186  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Queue>::Type
12187  Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT
12188  {
12189  VULKAN_HPP_NAMESPACE::Queue queue;
12190  getDispatcher()->vkGetDeviceQueue( static_cast<VkDevice>( m_device ), queueFamilyIndex, queueIndex, reinterpret_cast<VkQueue *>( &queue ) );
12191 
12192  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Queue( *this, *reinterpret_cast<VkQueue *>( &queue ) );
12193  }
12194 
12195  VULKAN_HPP_INLINE void Queue::submit( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo> const & submits,
12196  VULKAN_HPP_NAMESPACE::Fence fence ) const
12197  {
12198  VULKAN_HPP_ASSERT( getDispatcher()->vkQueueSubmit && "Function <vkQueueSubmit> requires <VK_VERSION_1_0>" );
12199 
12200  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkQueueSubmit(
12201  static_cast<VkQueue>( m_queue ), submits.size(), reinterpret_cast<const VkSubmitInfo *>( submits.data() ), static_cast<VkFence>( fence ) ) );
12202  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::submit" );
12203  }
12204 
12205  VULKAN_HPP_INLINE void Queue::waitIdle() const
12206  {
12207  VULKAN_HPP_ASSERT( getDispatcher()->vkQueueWaitIdle && "Function <vkQueueWaitIdle> requires <VK_VERSION_1_0>" );
12208 
12209  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkQueueWaitIdle( static_cast<VkQueue>( m_queue ) ) );
12210  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::waitIdle" );
12211  }
12212 
12213  VULKAN_HPP_INLINE void Device::waitIdle() const
12214  {
12215  VULKAN_HPP_ASSERT( getDispatcher()->vkDeviceWaitIdle && "Function <vkDeviceWaitIdle> requires <VK_VERSION_1_0>" );
12216 
12217  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkDeviceWaitIdle( static_cast<VkDevice>( m_device ) ) );
12218  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitIdle" );
12219  }
12220 
12222  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceMemory>::Type
12223  Device::allocateMemory( VULKAN_HPP_NAMESPACE::MemoryAllocateInfo const & allocateInfo,
12224  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT
12225  {
12226  VULKAN_HPP_NAMESPACE::DeviceMemory memory;
12227  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkAllocateMemory(
12228  static_cast<VkDevice>( m_device ),
12229  reinterpret_cast<const VkMemoryAllocateInfo *>( &allocateInfo ),
12230  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
12231  reinterpret_cast<VkDeviceMemory *>( &memory ) ) );
12232  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
12233  {
12234 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
12235  return VULKAN_HPP_UNEXPECTED( result );
12236 # else
12237  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::allocateMemory" );
12238 # endif
12239  }
12240 
12241  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceMemory( *this, *reinterpret_cast<VkDeviceMemory *>( &memory ), allocator );
12242  }
12243 
12247  {
12248  VULKAN_HPP_ASSERT( getDispatcher()->vkMapMemory && "Function <vkMapMemory> requires <VK_VERSION_1_0>" );
12249 
12250  void * pData;
12251  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkMapMemory( static_cast<VkDevice>( m_device ),
12252  static_cast<VkDeviceMemory>( m_memory ),
12253  static_cast<VkDeviceSize>( offset ),
12254  static_cast<VkDeviceSize>( size ),
12255  static_cast<VkMemoryMapFlags>( flags ),
12256  &pData ) );
12257  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::DeviceMemory::mapMemory" );
12258 
12259  return pData;
12260  }
12261 
12262  VULKAN_HPP_INLINE void DeviceMemory::unmapMemory() const VULKAN_HPP_NOEXCEPT
12263  {
12264  VULKAN_HPP_ASSERT( getDispatcher()->vkUnmapMemory && "Function <vkUnmapMemory> requires <VK_VERSION_1_0>" );
12265 
12266  getDispatcher()->vkUnmapMemory( static_cast<VkDevice>( m_device ), static_cast<VkDeviceMemory>( m_memory ) );
12267  }
12268 
12269  VULKAN_HPP_INLINE void
12270  Device::flushMappedMemoryRanges( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges ) const
12271  {
12272  VULKAN_HPP_ASSERT( getDispatcher()->vkFlushMappedMemoryRanges && "Function <vkFlushMappedMemoryRanges> requires <VK_VERSION_1_0>" );
12273 
12274  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkFlushMappedMemoryRanges(
12275  static_cast<VkDevice>( m_device ), memoryRanges.size(), reinterpret_cast<const VkMappedMemoryRange *>( memoryRanges.data() ) ) );
12276  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::flushMappedMemoryRanges" );
12277  }
12278 
12279  VULKAN_HPP_INLINE void
12280  Device::invalidateMappedMemoryRanges( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MappedMemoryRange> const & memoryRanges ) const
12281  {
12282  VULKAN_HPP_ASSERT( getDispatcher()->vkInvalidateMappedMemoryRanges && "Function <vkInvalidateMappedMemoryRanges> requires <VK_VERSION_1_0>" );
12283 
12284  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkInvalidateMappedMemoryRanges(
12285  static_cast<VkDevice>( m_device ), memoryRanges.size(), reinterpret_cast<const VkMappedMemoryRange *>( memoryRanges.data() ) ) );
12286  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::invalidateMappedMemoryRanges" );
12287  }
12288 
12290  {
12291  VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceMemoryCommitment && "Function <vkGetDeviceMemoryCommitment> requires <VK_VERSION_1_0>" );
12292 
12293  VULKAN_HPP_NAMESPACE::DeviceSize committedMemoryInBytes;
12294  getDispatcher()->vkGetDeviceMemoryCommitment(
12295  static_cast<VkDevice>( m_device ), static_cast<VkDeviceMemory>( m_memory ), reinterpret_cast<VkDeviceSize *>( &committedMemoryInBytes ) );
12296 
12297  return committedMemoryInBytes;
12298  }
12299 
12300  VULKAN_HPP_INLINE void Buffer::bindMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset ) const
12301  {
12302  VULKAN_HPP_ASSERT( getDispatcher()->vkBindBufferMemory && "Function <vkBindBufferMemory> requires <VK_VERSION_1_0>" );
12303 
12305  static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkBindBufferMemory( static_cast<VkDevice>( m_device ),
12306  static_cast<VkBuffer>( m_buffer ),
12307  static_cast<VkDeviceMemory>( memory ),
12308  static_cast<VkDeviceSize>( memoryOffset ) ) );
12309  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Buffer::bindMemory" );
12310  }
12311 
12312  VULKAN_HPP_INLINE void Image::bindMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, VULKAN_HPP_NAMESPACE::DeviceSize memoryOffset ) const
12313  {
12314  VULKAN_HPP_ASSERT( getDispatcher()->vkBindImageMemory && "Function <vkBindImageMemory> requires <VK_VERSION_1_0>" );
12315 
12317  static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkBindImageMemory( static_cast<VkDevice>( m_device ),
12318  static_cast<VkImage>( m_image ),
12319  static_cast<VkDeviceMemory>( memory ),
12320  static_cast<VkDeviceSize>( memoryOffset ) ) );
12321  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Image::bindMemory" );
12322  }
12323 
12324  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements Buffer::getMemoryRequirements() const VULKAN_HPP_NOEXCEPT
12325  {
12326  VULKAN_HPP_ASSERT( getDispatcher()->vkGetBufferMemoryRequirements && "Function <vkGetBufferMemoryRequirements> requires <VK_VERSION_1_0>" );
12327 
12328  VULKAN_HPP_NAMESPACE::MemoryRequirements memoryRequirements;
12329  getDispatcher()->vkGetBufferMemoryRequirements(
12330  static_cast<VkDevice>( m_device ), static_cast<VkBuffer>( m_buffer ), reinterpret_cast<VkMemoryRequirements *>( &memoryRequirements ) );
12331 
12332  return memoryRequirements;
12333  }
12334 
12335  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements Image::getMemoryRequirements() const VULKAN_HPP_NOEXCEPT
12336  {
12337  VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageMemoryRequirements && "Function <vkGetImageMemoryRequirements> requires <VK_VERSION_1_0>" );
12338 
12339  VULKAN_HPP_NAMESPACE::MemoryRequirements memoryRequirements;
12340  getDispatcher()->vkGetImageMemoryRequirements(
12341  static_cast<VkDevice>( m_device ), static_cast<VkImage>( m_image ), reinterpret_cast<VkMemoryRequirements *>( &memoryRequirements ) );
12342 
12343  return memoryRequirements;
12344  }
12345 
12346  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements> Image::getSparseMemoryRequirements() const
12347  {
12348  VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageSparseMemoryRequirements && "Function <vkGetImageSparseMemoryRequirements> requires <VK_VERSION_1_0>" );
12349 
12350  std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements> sparseMemoryRequirements;
12351  uint32_t sparseMemoryRequirementCount;
12352  getDispatcher()->vkGetImageSparseMemoryRequirements(
12353  static_cast<VkDevice>( m_device ), static_cast<VkImage>( m_image ), &sparseMemoryRequirementCount, nullptr );
12354  sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
12355  getDispatcher()->vkGetImageSparseMemoryRequirements( static_cast<VkDevice>( m_device ),
12356  static_cast<VkImage>( m_image ),
12357  &sparseMemoryRequirementCount,
12358  reinterpret_cast<VkSparseImageMemoryRequirements *>( sparseMemoryRequirements.data() ) );
12359 
12360  VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
12361  if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() )
12362  {
12363  sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
12364  }
12365  return sparseMemoryRequirements;
12366  }
12367 
12368  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>
12369  PhysicalDevice::getSparseImageFormatProperties( VULKAN_HPP_NAMESPACE::Format format,
12373  VULKAN_HPP_NAMESPACE::ImageTiling tiling ) const
12374  {
12376  "Function <vkGetPhysicalDeviceSparseImageFormatProperties> requires <VK_VERSION_1_0>" );
12377 
12378  std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties> properties;
12379  uint32_t propertyCount;
12380  getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ),
12381  static_cast<VkFormat>( format ),
12382  static_cast<VkImageType>( type ),
12383  static_cast<VkSampleCountFlagBits>( samples ),
12384  static_cast<VkImageUsageFlags>( usage ),
12385  static_cast<VkImageTiling>( tiling ),
12386  &propertyCount,
12387  nullptr );
12388  properties.resize( propertyCount );
12389  getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ),
12390  static_cast<VkFormat>( format ),
12391  static_cast<VkImageType>( type ),
12392  static_cast<VkSampleCountFlagBits>( samples ),
12393  static_cast<VkImageUsageFlags>( usage ),
12394  static_cast<VkImageTiling>( tiling ),
12395  &propertyCount,
12396  reinterpret_cast<VkSparseImageFormatProperties *>( properties.data() ) );
12397 
12398  VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
12399  if ( propertyCount < properties.size() )
12400  {
12401  properties.resize( propertyCount );
12402  }
12403  return properties;
12404  }
12405 
12406  VULKAN_HPP_INLINE void Queue::bindSparse( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindSparseInfo> const & bindInfo,
12407  VULKAN_HPP_NAMESPACE::Fence fence ) const
12408  {
12409  VULKAN_HPP_ASSERT( getDispatcher()->vkQueueBindSparse && "Function <vkQueueBindSparse> requires <VK_VERSION_1_0>" );
12410 
12411  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkQueueBindSparse(
12412  static_cast<VkQueue>( m_queue ), bindInfo.size(), reinterpret_cast<const VkBindSparseInfo *>( bindInfo.data() ), static_cast<VkFence>( fence ) ) );
12413  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::bindSparse" );
12414  }
12415 
12417  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Fence>::Type
12418  Device::createFence( VULKAN_HPP_NAMESPACE::FenceCreateInfo const & createInfo,
12419  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT
12420  {
12421  VULKAN_HPP_NAMESPACE::Fence fence;
12422  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateFence(
12423  static_cast<VkDevice>( m_device ),
12424  reinterpret_cast<const VkFenceCreateInfo *>( &createInfo ),
12425  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
12426  reinterpret_cast<VkFence *>( &fence ) ) );
12427  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
12428  {
12429 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
12430  return VULKAN_HPP_UNEXPECTED( result );
12431 # else
12432  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createFence" );
12433 # endif
12434  }
12435 
12436  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Fence( *this, *reinterpret_cast<VkFence *>( &fence ), allocator );
12437  }
12438 
12439  VULKAN_HPP_INLINE void Device::resetFences( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences ) const
12440  {
12441  VULKAN_HPP_ASSERT( getDispatcher()->vkResetFences && "Function <vkResetFences> requires <VK_VERSION_1_0>" );
12442 
12444  getDispatcher()->vkResetFences( static_cast<VkDevice>( m_device ), fences.size(), reinterpret_cast<const VkFence *>( fences.data() ) ) );
12445  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetFences" );
12446  }
12447 
12449  {
12450  VULKAN_HPP_ASSERT( getDispatcher()->vkGetFenceStatus && "Function <vkGetFenceStatus> requires <VK_VERSION_1_0>" );
12451 
12453  static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetFenceStatus( static_cast<VkDevice>( m_device ), static_cast<VkFence>( m_fence ) ) );
12454  resultCheck(
12455  result, VULKAN_HPP_NAMESPACE_STRING "::Fence::getStatus", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } );
12456 
12457  return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
12458  }
12459 
12461  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Fence> const & fences, VULKAN_HPP_NAMESPACE::Bool32 waitAll, uint64_t timeout ) const
12462  {
12463  VULKAN_HPP_ASSERT( getDispatcher()->vkWaitForFences && "Function <vkWaitForFences> requires <VK_VERSION_1_0>" );
12464 
12465  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkWaitForFences(
12466  static_cast<VkDevice>( m_device ), fences.size(), reinterpret_cast<const VkFence *>( fences.data() ), static_cast<VkBool32>( waitAll ), timeout ) );
12467  resultCheck(
12468  result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitForFences", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout } );
12469 
12470  return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
12471  }
12472 
12474  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Semaphore>::Type
12475  Device::createSemaphore( VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo const & createInfo,
12476  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT
12477  {
12478  VULKAN_HPP_NAMESPACE::Semaphore semaphore;
12479  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateSemaphore(
12480  static_cast<VkDevice>( m_device ),
12481  reinterpret_cast<const VkSemaphoreCreateInfo *>( &createInfo ),
12482  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
12483  reinterpret_cast<VkSemaphore *>( &semaphore ) ) );
12484  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
12485  {
12486 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
12487  return VULKAN_HPP_UNEXPECTED( result );
12488 # else
12489  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createSemaphore" );
12490 # endif
12491  }
12492 
12493  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Semaphore( *this, *reinterpret_cast<VkSemaphore *>( &semaphore ), allocator );
12494  }
12495 
12497  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Event>::Type
12498  Device::createEvent( VULKAN_HPP_NAMESPACE::EventCreateInfo const & createInfo,
12499  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT
12500  {
12501  VULKAN_HPP_NAMESPACE::Event event;
12502  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateEvent(
12503  static_cast<VkDevice>( m_device ),
12504  reinterpret_cast<const VkEventCreateInfo *>( &createInfo ),
12505  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
12506  reinterpret_cast<VkEvent *>( &event ) ) );
12507  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
12508  {
12509 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
12510  return VULKAN_HPP_UNEXPECTED( result );
12511 # else
12512  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createEvent" );
12513 # endif
12514  }
12515 
12516  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Event( *this, *reinterpret_cast<VkEvent *>( &event ), allocator );
12517  }
12518 
12520  {
12521  VULKAN_HPP_ASSERT( getDispatcher()->vkGetEventStatus && "Function <vkGetEventStatus> requires <VK_VERSION_1_0>" );
12522 
12524  static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetEventStatus( static_cast<VkDevice>( m_device ), static_cast<VkEvent>( m_event ) ) );
12525  resultCheck(
12526  result, VULKAN_HPP_NAMESPACE_STRING "::Event::getStatus", { VULKAN_HPP_NAMESPACE::Result::eEventSet, VULKAN_HPP_NAMESPACE::Result::eEventReset } );
12527 
12528  return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
12529  }
12530 
12531  VULKAN_HPP_INLINE void Event::set() const
12532  {
12533  VULKAN_HPP_ASSERT( getDispatcher()->vkSetEvent && "Function <vkSetEvent> requires <VK_VERSION_1_0>" );
12534 
12536  static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkSetEvent( static_cast<VkDevice>( m_device ), static_cast<VkEvent>( m_event ) ) );
12537  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Event::set" );
12538  }
12539 
12540  VULKAN_HPP_INLINE void Event::reset() const
12541  {
12542  VULKAN_HPP_ASSERT( getDispatcher()->vkResetEvent && "Function <vkResetEvent> requires <VK_VERSION_1_0>" );
12543 
12545  static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkResetEvent( static_cast<VkDevice>( m_device ), static_cast<VkEvent>( m_event ) ) );
12546  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Event::reset" );
12547  }
12548 
12550  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::QueryPool>::Type
12551  Device::createQueryPool( VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo const & createInfo,
12552  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT
12553  {
12554  VULKAN_HPP_NAMESPACE::QueryPool queryPool;
12555  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateQueryPool(
12556  static_cast<VkDevice>( m_device ),
12557  reinterpret_cast<const VkQueryPoolCreateInfo *>( &createInfo ),
12558  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
12559  reinterpret_cast<VkQueryPool *>( &queryPool ) ) );
12560  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
12561  {
12562 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
12563  return VULKAN_HPP_UNEXPECTED( result );
12564 # else
12565  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createQueryPool" );
12566 # endif
12567  }
12568 
12569  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::QueryPool( *this, *reinterpret_cast<VkQueryPool *>( &queryPool ), allocator );
12570  }
12571 
12572  template <typename DataType>
12573  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, std::vector<DataType>> QueryPool::getResults(
12574  uint32_t firstQuery, uint32_t queryCount, size_t dataSize, VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::QueryResultFlags flags ) const
12575  {
12576  VULKAN_HPP_ASSERT( getDispatcher()->vkGetQueryPoolResults && "Function <vkGetQueryPoolResults> requires <VK_VERSION_1_0>" );
12577 
12578  VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
12579  std::vector<DataType> data( dataSize / sizeof( DataType ) );
12581  static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetQueryPoolResults( static_cast<VkDevice>( m_device ),
12582  static_cast<VkQueryPool>( m_queryPool ),
12583  firstQuery,
12584  queryCount,
12585  data.size() * sizeof( DataType ),
12586  reinterpret_cast<void *>( data.data() ),
12587  static_cast<VkDeviceSize>( stride ),
12588  static_cast<VkQueryResultFlags>( flags ) ) );
12589  resultCheck(
12590  result, VULKAN_HPP_NAMESPACE_STRING "::QueryPool::getResults", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } );
12591 
12592  return std::make_pair( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data );
12593  }
12594 
12595  template <typename DataType>
12596  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, DataType> QueryPool::getResult(
12597  uint32_t firstQuery, uint32_t queryCount, VULKAN_HPP_NAMESPACE::DeviceSize stride, VULKAN_HPP_NAMESPACE::QueryResultFlags flags ) const
12598  {
12599  VULKAN_HPP_ASSERT( getDispatcher()->vkGetQueryPoolResults && "Function <vkGetQueryPoolResults> requires <VK_VERSION_1_0>" );
12600 
12601  DataType data;
12603  static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetQueryPoolResults( static_cast<VkDevice>( m_device ),
12604  static_cast<VkQueryPool>( m_queryPool ),
12605  firstQuery,
12606  queryCount,
12607  sizeof( DataType ),
12608  reinterpret_cast<void *>( &data ),
12609  static_cast<VkDeviceSize>( stride ),
12610  static_cast<VkQueryResultFlags>( flags ) ) );
12611  resultCheck(
12612  result, VULKAN_HPP_NAMESPACE_STRING "::QueryPool::getResult", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eNotReady } );
12613 
12614  return std::make_pair( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data );
12615  }
12616 
12618  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Buffer>::Type
12619  Device::createBuffer( VULKAN_HPP_NAMESPACE::BufferCreateInfo const & createInfo,
12620  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT
12621  {
12622  VULKAN_HPP_NAMESPACE::Buffer buffer;
12623  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateBuffer(
12624  static_cast<VkDevice>( m_device ),
12625  reinterpret_cast<const VkBufferCreateInfo *>( &createInfo ),
12626  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
12627  reinterpret_cast<VkBuffer *>( &buffer ) ) );
12628  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
12629  {
12630 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
12631  return VULKAN_HPP_UNEXPECTED( result );
12632 # else
12633  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createBuffer" );
12634 # endif
12635  }
12636 
12637  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Buffer( *this, *reinterpret_cast<VkBuffer *>( &buffer ), allocator );
12638  }
12639 
12641  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::BufferView>::Type
12642  Device::createBufferView( VULKAN_HPP_NAMESPACE::BufferViewCreateInfo const & createInfo,
12643  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
12645  {
12646  VULKAN_HPP_NAMESPACE::BufferView view;
12647  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateBufferView(
12648  static_cast<VkDevice>( m_device ),
12649  reinterpret_cast<const VkBufferViewCreateInfo *>( &createInfo ),
12650  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
12651  reinterpret_cast<VkBufferView *>( &view ) ) );
12652  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
12653  {
12654 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
12655  return VULKAN_HPP_UNEXPECTED( result );
12656 # else
12657  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createBufferView" );
12658 # endif
12659  }
12660 
12661  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::BufferView( *this, *reinterpret_cast<VkBufferView *>( &view ), allocator );
12662  }
12663 
12665  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Image>::Type
12666  Device::createImage( VULKAN_HPP_NAMESPACE::ImageCreateInfo const & createInfo,
12667  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT
12668  {
12669  VULKAN_HPP_NAMESPACE::Image image;
12670  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateImage(
12671  static_cast<VkDevice>( m_device ),
12672  reinterpret_cast<const VkImageCreateInfo *>( &createInfo ),
12673  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
12674  reinterpret_cast<VkImage *>( &image ) ) );
12675  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
12676  {
12677 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
12678  return VULKAN_HPP_UNEXPECTED( result );
12679 # else
12680  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createImage" );
12681 # endif
12682  }
12683 
12684  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Image( *this, *reinterpret_cast<VkImage *>( &image ), allocator );
12685  }
12686 
12687  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SubresourceLayout
12688  Image::getSubresourceLayout( const VULKAN_HPP_NAMESPACE::ImageSubresource & subresource ) const VULKAN_HPP_NOEXCEPT
12689  {
12690  VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageSubresourceLayout && "Function <vkGetImageSubresourceLayout> requires <VK_VERSION_1_0>" );
12691 
12692  VULKAN_HPP_NAMESPACE::SubresourceLayout layout;
12693  getDispatcher()->vkGetImageSubresourceLayout( static_cast<VkDevice>( m_device ),
12694  static_cast<VkImage>( m_image ),
12695  reinterpret_cast<const VkImageSubresource *>( &subresource ),
12696  reinterpret_cast<VkSubresourceLayout *>( &layout ) );
12697 
12698  return layout;
12699  }
12700 
12702  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ImageView>::Type
12703  Device::createImageView( VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const & createInfo,
12704  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT
12705  {
12706  VULKAN_HPP_NAMESPACE::ImageView view;
12707  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateImageView(
12708  static_cast<VkDevice>( m_device ),
12709  reinterpret_cast<const VkImageViewCreateInfo *>( &createInfo ),
12710  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
12711  reinterpret_cast<VkImageView *>( &view ) ) );
12712  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
12713  {
12714 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
12715  return VULKAN_HPP_UNEXPECTED( result );
12716 # else
12717  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createImageView" );
12718 # endif
12719  }
12720 
12721  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ImageView( *this, *reinterpret_cast<VkImageView *>( &view ), allocator );
12722  }
12723 
12725  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ShaderModule>::Type
12726  Device::createShaderModule( VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo const & createInfo,
12727  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
12729  {
12730  VULKAN_HPP_NAMESPACE::ShaderModule shaderModule;
12731  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateShaderModule(
12732  static_cast<VkDevice>( m_device ),
12733  reinterpret_cast<const VkShaderModuleCreateInfo *>( &createInfo ),
12734  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
12735  reinterpret_cast<VkShaderModule *>( &shaderModule ) ) );
12736  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
12737  {
12738 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
12739  return VULKAN_HPP_UNEXPECTED( result );
12740 # else
12741  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createShaderModule" );
12742 # endif
12743  }
12744 
12745  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ShaderModule( *this, *reinterpret_cast<VkShaderModule *>( &shaderModule ), allocator );
12746  }
12747 
12749  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache>::Type
12750  Device::createPipelineCache( VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo const & createInfo,
12751  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
12753  {
12754  VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache;
12755  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreatePipelineCache(
12756  static_cast<VkDevice>( m_device ),
12757  reinterpret_cast<const VkPipelineCacheCreateInfo *>( &createInfo ),
12758  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
12759  reinterpret_cast<VkPipelineCache *>( &pipelineCache ) ) );
12760  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
12761  {
12762 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
12763  return VULKAN_HPP_UNEXPECTED( result );
12764 # else
12765  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createPipelineCache" );
12766 # endif
12767  }
12768 
12769  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache( *this, *reinterpret_cast<VkPipelineCache *>( &pipelineCache ), allocator );
12770  }
12771 
12772  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<uint8_t> PipelineCache::getData() const
12773  {
12774  VULKAN_HPP_ASSERT( getDispatcher()->vkGetPipelineCacheData && "Function <vkGetPipelineCacheData> requires <VK_VERSION_1_0>" );
12775 
12776  std::vector<uint8_t> data;
12777  size_t dataSize;
12779  do
12780  {
12781  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
12782  getDispatcher()->vkGetPipelineCacheData( static_cast<VkDevice>( m_device ), static_cast<VkPipelineCache>( m_pipelineCache ), &dataSize, nullptr ) );
12783  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && dataSize )
12784  {
12785  data.resize( dataSize );
12786  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPipelineCacheData(
12787  static_cast<VkDevice>( m_device ), static_cast<VkPipelineCache>( m_pipelineCache ), &dataSize, reinterpret_cast<void *>( data.data() ) ) );
12788  }
12789  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
12790  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PipelineCache::getData" );
12791  VULKAN_HPP_ASSERT( dataSize <= data.size() );
12792  if ( dataSize < data.size() )
12793  {
12794  data.resize( dataSize );
12795  }
12796  return data;
12797  }
12798 
12799  VULKAN_HPP_INLINE void PipelineCache::merge( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::PipelineCache> const & srcCaches ) const
12800  {
12801  VULKAN_HPP_ASSERT( getDispatcher()->vkMergePipelineCaches && "Function <vkMergePipelineCaches> requires <VK_VERSION_1_0>" );
12802 
12804  static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkMergePipelineCaches( static_cast<VkDevice>( m_device ),
12805  static_cast<VkPipelineCache>( m_pipelineCache ),
12806  srcCaches.size(),
12807  reinterpret_cast<const VkPipelineCache *>( srcCaches.data() ) ) );
12808  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PipelineCache::merge" );
12809  }
12810 
12812  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>>::Type
12813  Device::createGraphicsPipelines(
12814  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,
12815  VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo> const & createInfos,
12816  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
12817  {
12818  std::vector<VULKAN_HPP_NAMESPACE::Pipeline> pipelines( createInfos.size() );
12819  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateGraphicsPipelines(
12820  static_cast<VkDevice>( m_device ),
12821  pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0,
12822  createInfos.size(),
12823  reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( createInfos.data() ),
12824  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
12825  reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
12826  if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( result != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) )
12827  {
12828 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
12829  return VULKAN_HPP_UNEXPECTED( result );
12830 # else
12831  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createGraphicsPipelines" );
12832 # endif
12833  }
12834 
12835  std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline> pipelinesRAII;
12836  pipelinesRAII.reserve( pipelines.size() );
12837  for ( auto & pipeline : pipelines )
12838  {
12839  pipelinesRAII.emplace_back( *this, *reinterpret_cast<VkPipeline *>( &pipeline ), allocator, result );
12840  }
12841  return pipelinesRAII;
12842  }
12843 
12845  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>::Type
12847  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,
12848  VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo const & createInfo,
12849  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT
12850  {
12851  VULKAN_HPP_NAMESPACE::Pipeline pipeline;
12852  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateGraphicsPipelines(
12853  static_cast<VkDevice>( m_device ),
12854  pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0,
12855  1,
12856  reinterpret_cast<const VkGraphicsPipelineCreateInfo *>( &createInfo ),
12857  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
12858  reinterpret_cast<VkPipeline *>( &pipeline ) ) );
12859  if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( result != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) )
12860  {
12861 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
12862  return VULKAN_HPP_UNEXPECTED( result );
12863 # else
12864  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createGraphicsPipeline" );
12865 # endif
12866  }
12867 
12868  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline( *this, *reinterpret_cast<VkPipeline *>( &pipeline ), allocator );
12869  }
12870 
12872  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>>::Type
12873  Device::createComputePipelines(
12874  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,
12875  VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo> const & createInfos,
12876  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
12877  {
12878  std::vector<VULKAN_HPP_NAMESPACE::Pipeline> pipelines( createInfos.size() );
12879  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateComputePipelines(
12880  static_cast<VkDevice>( m_device ),
12881  pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0,
12882  createInfos.size(),
12883  reinterpret_cast<const VkComputePipelineCreateInfo *>( createInfos.data() ),
12884  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
12885  reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
12886  if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( result != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) )
12887  {
12888 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
12889  return VULKAN_HPP_UNEXPECTED( result );
12890 # else
12891  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createComputePipelines" );
12892 # endif
12893  }
12894 
12895  std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline> pipelinesRAII;
12896  pipelinesRAII.reserve( pipelines.size() );
12897  for ( auto & pipeline : pipelines )
12898  {
12899  pipelinesRAII.emplace_back( *this, *reinterpret_cast<VkPipeline *>( &pipeline ), allocator, result );
12900  }
12901  return pipelinesRAII;
12902  }
12903 
12905  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>::Type
12906  Device::createComputePipeline( VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,
12907  VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo const & createInfo,
12908  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
12910  {
12911  VULKAN_HPP_NAMESPACE::Pipeline pipeline;
12912  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateComputePipelines(
12913  static_cast<VkDevice>( m_device ),
12914  pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0,
12915  1,
12916  reinterpret_cast<const VkComputePipelineCreateInfo *>( &createInfo ),
12917  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
12918  reinterpret_cast<VkPipeline *>( &pipeline ) ) );
12919  if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( result != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) )
12920  {
12921 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
12922  return VULKAN_HPP_UNEXPECTED( result );
12923 # else
12924  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createComputePipeline" );
12925 # endif
12926  }
12927 
12928  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline( *this, *reinterpret_cast<VkPipeline *>( &pipeline ), allocator );
12929  }
12930 
12932  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineLayout>::Type
12933  Device::createPipelineLayout( VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo const & createInfo,
12934  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
12936  {
12937  VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout;
12938  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreatePipelineLayout(
12939  static_cast<VkDevice>( m_device ),
12940  reinterpret_cast<const VkPipelineLayoutCreateInfo *>( &createInfo ),
12941  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
12942  reinterpret_cast<VkPipelineLayout *>( &pipelineLayout ) ) );
12943  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
12944  {
12945 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
12946  return VULKAN_HPP_UNEXPECTED( result );
12947 # else
12948  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createPipelineLayout" );
12949 # endif
12950  }
12951 
12952  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineLayout( *this, *reinterpret_cast<VkPipelineLayout *>( &pipelineLayout ), allocator );
12953  }
12954 
12956  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Sampler>::Type
12957  Device::createSampler( VULKAN_HPP_NAMESPACE::SamplerCreateInfo const & createInfo,
12958  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT
12959  {
12960  VULKAN_HPP_NAMESPACE::Sampler sampler;
12961  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateSampler(
12962  static_cast<VkDevice>( m_device ),
12963  reinterpret_cast<const VkSamplerCreateInfo *>( &createInfo ),
12964  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
12965  reinterpret_cast<VkSampler *>( &sampler ) ) );
12966  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
12967  {
12968 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
12969  return VULKAN_HPP_UNEXPECTED( result );
12970 # else
12971  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createSampler" );
12972 # endif
12973  }
12974 
12975  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Sampler( *this, *reinterpret_cast<VkSampler *>( &sampler ), allocator );
12976  }
12977 
12979  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSetLayout>::Type
12980  Device::createDescriptorSetLayout( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo const & createInfo,
12981  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
12983  {
12984  VULKAN_HPP_NAMESPACE::DescriptorSetLayout setLayout;
12985  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateDescriptorSetLayout(
12986  static_cast<VkDevice>( m_device ),
12987  reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
12988  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
12989  reinterpret_cast<VkDescriptorSetLayout *>( &setLayout ) ) );
12990  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
12991  {
12992 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
12993  return VULKAN_HPP_UNEXPECTED( result );
12994 # else
12995  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createDescriptorSetLayout" );
12996 # endif
12997  }
12998 
12999  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSetLayout( *this, *reinterpret_cast<VkDescriptorSetLayout *>( &setLayout ), allocator );
13000  }
13001 
13003  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorPool>::Type
13004  Device::createDescriptorPool( VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo const & createInfo,
13005  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
13007  {
13008  VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool;
13009  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateDescriptorPool(
13010  static_cast<VkDevice>( m_device ),
13011  reinterpret_cast<const VkDescriptorPoolCreateInfo *>( &createInfo ),
13012  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
13013  reinterpret_cast<VkDescriptorPool *>( &descriptorPool ) ) );
13014  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
13015  {
13016 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
13017  return VULKAN_HPP_UNEXPECTED( result );
13018 # else
13019  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createDescriptorPool" );
13020 # endif
13021  }
13022 
13023  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorPool( *this, *reinterpret_cast<VkDescriptorPool *>( &descriptorPool ), allocator );
13024  }
13025 
13027  {
13028  VULKAN_HPP_ASSERT( getDispatcher()->vkResetDescriptorPool && "Function <vkResetDescriptorPool> requires <VK_VERSION_1_0>" );
13029 
13030  getDispatcher()->vkResetDescriptorPool(
13031  static_cast<VkDevice>( m_device ), static_cast<VkDescriptorPool>( m_descriptorPool ), static_cast<VkDescriptorPoolResetFlags>( flags ) );
13032  }
13033 
13035  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSet>>::Type
13036  Device::allocateDescriptorSets( VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo const & allocateInfo ) const
13037  {
13038  std::vector<VULKAN_HPP_NAMESPACE::DescriptorSet> descriptorSets( allocateInfo.descriptorSetCount );
13040  getDispatcher()->vkAllocateDescriptorSets( static_cast<VkDevice>( m_device ),
13041  reinterpret_cast<const VkDescriptorSetAllocateInfo *>( &allocateInfo ),
13042  reinterpret_cast<VkDescriptorSet *>( descriptorSets.data() ) ) );
13043  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
13044  {
13045 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
13046  return VULKAN_HPP_UNEXPECTED( result );
13047 # else
13048  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::allocateDescriptorSets" );
13049 # endif
13050  }
13051 
13052  std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorSet> descriptorSetsRAII;
13053  descriptorSetsRAII.reserve( descriptorSets.size() );
13054  for ( auto & descriptorSet : descriptorSets )
13055  {
13056  descriptorSetsRAII.emplace_back(
13057  *this, *reinterpret_cast<VkDescriptorSet *>( &descriptorSet ), static_cast<VkDescriptorPool>( allocateInfo.descriptorPool ) );
13058  }
13059  return descriptorSetsRAII;
13060  }
13061 
13063  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites,
13064  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CopyDescriptorSet> const & descriptorCopies ) const VULKAN_HPP_NOEXCEPT
13065  {
13066  VULKAN_HPP_ASSERT( getDispatcher()->vkUpdateDescriptorSets && "Function <vkUpdateDescriptorSets> requires <VK_VERSION_1_0>" );
13067 
13068  getDispatcher()->vkUpdateDescriptorSets( static_cast<VkDevice>( m_device ),
13069  descriptorWrites.size(),
13070  reinterpret_cast<const VkWriteDescriptorSet *>( descriptorWrites.data() ),
13071  descriptorCopies.size(),
13072  reinterpret_cast<const VkCopyDescriptorSet *>( descriptorCopies.data() ) );
13073  }
13074 
13076  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Framebuffer>::Type
13077  Device::createFramebuffer( VULKAN_HPP_NAMESPACE::FramebufferCreateInfo const & createInfo,
13078  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
13080  {
13081  VULKAN_HPP_NAMESPACE::Framebuffer framebuffer;
13082  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateFramebuffer(
13083  static_cast<VkDevice>( m_device ),
13084  reinterpret_cast<const VkFramebufferCreateInfo *>( &createInfo ),
13085  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
13086  reinterpret_cast<VkFramebuffer *>( &framebuffer ) ) );
13087  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
13088  {
13089 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
13090  return VULKAN_HPP_UNEXPECTED( result );
13091 # else
13092  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createFramebuffer" );
13093 # endif
13094  }
13095 
13096  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Framebuffer( *this, *reinterpret_cast<VkFramebuffer *>( &framebuffer ), allocator );
13097  }
13098 
13100  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::RenderPass>::Type
13101  Device::createRenderPass( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo const & createInfo,
13102  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
13104  {
13105  VULKAN_HPP_NAMESPACE::RenderPass renderPass;
13106  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateRenderPass(
13107  static_cast<VkDevice>( m_device ),
13108  reinterpret_cast<const VkRenderPassCreateInfo *>( &createInfo ),
13109  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
13110  reinterpret_cast<VkRenderPass *>( &renderPass ) ) );
13111  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
13112  {
13113 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
13114  return VULKAN_HPP_UNEXPECTED( result );
13115 # else
13116  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createRenderPass" );
13117 # endif
13118  }
13119 
13120  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::RenderPass( *this, *reinterpret_cast<VkRenderPass *>( &renderPass ), allocator );
13121  }
13122 
13123  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Extent2D RenderPass::getRenderAreaGranularity() const VULKAN_HPP_NOEXCEPT
13124  {
13125  VULKAN_HPP_ASSERT( getDispatcher()->vkGetRenderAreaGranularity && "Function <vkGetRenderAreaGranularity> requires <VK_VERSION_1_0>" );
13126 
13127  VULKAN_HPP_NAMESPACE::Extent2D granularity;
13128  getDispatcher()->vkGetRenderAreaGranularity(
13129  static_cast<VkDevice>( m_device ), static_cast<VkRenderPass>( m_renderPass ), reinterpret_cast<VkExtent2D *>( &granularity ) );
13130 
13131  return granularity;
13132  }
13133 
13135  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CommandPool>::Type
13136  Device::createCommandPool( VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo const & createInfo,
13137  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
13139  {
13140  VULKAN_HPP_NAMESPACE::CommandPool commandPool;
13141  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateCommandPool(
13142  static_cast<VkDevice>( m_device ),
13143  reinterpret_cast<const VkCommandPoolCreateInfo *>( &createInfo ),
13144  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
13145  reinterpret_cast<VkCommandPool *>( &commandPool ) ) );
13146  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
13147  {
13148 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
13149  return VULKAN_HPP_UNEXPECTED( result );
13150 # else
13151  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createCommandPool" );
13152 # endif
13153  }
13154 
13155  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CommandPool( *this, *reinterpret_cast<VkCommandPool *>( &commandPool ), allocator );
13156  }
13157 
13159  {
13160  VULKAN_HPP_ASSERT( getDispatcher()->vkResetCommandPool && "Function <vkResetCommandPool> requires <VK_VERSION_1_0>" );
13161 
13162  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkResetCommandPool(
13163  static_cast<VkDevice>( m_device ), static_cast<VkCommandPool>( m_commandPool ), static_cast<VkCommandPoolResetFlags>( flags ) ) );
13164  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandPool::reset" );
13165  }
13166 
13168  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CommandBuffer>>::Type
13169  Device::allocateCommandBuffers( VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo const & allocateInfo ) const
13170  {
13171  std::vector<VULKAN_HPP_NAMESPACE::CommandBuffer> commandBuffers( allocateInfo.commandBufferCount );
13173  getDispatcher()->vkAllocateCommandBuffers( static_cast<VkDevice>( m_device ),
13174  reinterpret_cast<const VkCommandBufferAllocateInfo *>( &allocateInfo ),
13175  reinterpret_cast<VkCommandBuffer *>( commandBuffers.data() ) ) );
13176  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
13177  {
13178 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
13179  return VULKAN_HPP_UNEXPECTED( result );
13180 # else
13181  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::allocateCommandBuffers" );
13182 # endif
13183  }
13184 
13185  std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CommandBuffer> commandBuffersRAII;
13186  commandBuffersRAII.reserve( commandBuffers.size() );
13187  for ( auto & commandBuffer : commandBuffers )
13188  {
13189  commandBuffersRAII.emplace_back(
13190  *this, *reinterpret_cast<VkCommandBuffer *>( &commandBuffer ), static_cast<VkCommandPool>( allocateInfo.commandPool ) );
13191  }
13192  return commandBuffersRAII;
13193  }
13194 
13195  VULKAN_HPP_INLINE void CommandBuffer::begin( const VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo & beginInfo ) const
13196  {
13197  VULKAN_HPP_ASSERT( getDispatcher()->vkBeginCommandBuffer && "Function <vkBeginCommandBuffer> requires <VK_VERSION_1_0>" );
13198 
13199  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkBeginCommandBuffer(
13200  static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCommandBufferBeginInfo *>( &beginInfo ) ) );
13201  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::begin" );
13202  }
13203 
13204  VULKAN_HPP_INLINE void CommandBuffer::end() const
13205  {
13206  VULKAN_HPP_ASSERT( getDispatcher()->vkEndCommandBuffer && "Function <vkEndCommandBuffer> requires <VK_VERSION_1_0>" );
13207 
13209  static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEndCommandBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ) ) );
13210  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::end" );
13211  }
13212 
13213  VULKAN_HPP_INLINE void CommandBuffer::reset( VULKAN_HPP_NAMESPACE::CommandBufferResetFlags flags ) const
13214  {
13215  VULKAN_HPP_ASSERT( getDispatcher()->vkResetCommandBuffer && "Function <vkResetCommandBuffer> requires <VK_VERSION_1_0>" );
13216 
13218  getDispatcher()->vkResetCommandBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkCommandBufferResetFlags>( flags ) ) );
13219  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::reset" );
13220  }
13221 
13222  VULKAN_HPP_INLINE void CommandBuffer::bindPipeline( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
13223  VULKAN_HPP_NAMESPACE::Pipeline pipeline ) const VULKAN_HPP_NOEXCEPT
13224  {
13225  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindPipeline && "Function <vkCmdBindPipeline> requires <VK_VERSION_1_0>" );
13226 
13227  getDispatcher()->vkCmdBindPipeline(
13228  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipeline>( pipeline ) );
13229  }
13230 
13231  VULKAN_HPP_INLINE void
13232  CommandBuffer::setViewport( uint32_t firstViewport,
13233  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports ) const VULKAN_HPP_NOEXCEPT
13234  {
13235  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetViewport && "Function <vkCmdSetViewport> requires <VK_VERSION_1_0>" );
13236 
13237  getDispatcher()->vkCmdSetViewport(
13238  static_cast<VkCommandBuffer>( m_commandBuffer ), firstViewport, viewports.size(), reinterpret_cast<const VkViewport *>( viewports.data() ) );
13239  }
13240 
13241  VULKAN_HPP_INLINE void
13242  CommandBuffer::setScissor( uint32_t firstScissor,
13243  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors ) const VULKAN_HPP_NOEXCEPT
13244  {
13245  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetScissor && "Function <vkCmdSetScissor> requires <VK_VERSION_1_0>" );
13246 
13247  getDispatcher()->vkCmdSetScissor(
13248  static_cast<VkCommandBuffer>( m_commandBuffer ), firstScissor, scissors.size(), reinterpret_cast<const VkRect2D *>( scissors.data() ) );
13249  }
13250 
13251  VULKAN_HPP_INLINE void CommandBuffer::setLineWidth( float lineWidth ) const VULKAN_HPP_NOEXCEPT
13252  {
13253  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLineWidth && "Function <vkCmdSetLineWidth> requires <VK_VERSION_1_0>" );
13254 
13255  getDispatcher()->vkCmdSetLineWidth( static_cast<VkCommandBuffer>( m_commandBuffer ), lineWidth );
13256  }
13257 
13258  VULKAN_HPP_INLINE void
13259  CommandBuffer::setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor ) const VULKAN_HPP_NOEXCEPT
13260  {
13261  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthBias && "Function <vkCmdSetDepthBias> requires <VK_VERSION_1_0>" );
13262 
13263  getDispatcher()->vkCmdSetDepthBias( static_cast<VkCommandBuffer>( m_commandBuffer ), depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor );
13264  }
13265 
13266  VULKAN_HPP_INLINE void CommandBuffer::setBlendConstants( const float blendConstants[4] ) const VULKAN_HPP_NOEXCEPT
13267  {
13268  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetBlendConstants && "Function <vkCmdSetBlendConstants> requires <VK_VERSION_1_0>" );
13269 
13270  getDispatcher()->vkCmdSetBlendConstants( static_cast<VkCommandBuffer>( m_commandBuffer ), blendConstants );
13271  }
13272 
13273  VULKAN_HPP_INLINE void CommandBuffer::setDepthBounds( float minDepthBounds, float maxDepthBounds ) const VULKAN_HPP_NOEXCEPT
13274  {
13275  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthBounds && "Function <vkCmdSetDepthBounds> requires <VK_VERSION_1_0>" );
13276 
13277  getDispatcher()->vkCmdSetDepthBounds( static_cast<VkCommandBuffer>( m_commandBuffer ), minDepthBounds, maxDepthBounds );
13278  }
13279 
13280  VULKAN_HPP_INLINE void CommandBuffer::setStencilCompareMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
13281  uint32_t compareMask ) const VULKAN_HPP_NOEXCEPT
13282  {
13283  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilCompareMask && "Function <vkCmdSetStencilCompareMask> requires <VK_VERSION_1_0>" );
13284 
13285  getDispatcher()->vkCmdSetStencilCompareMask( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkStencilFaceFlags>( faceMask ), compareMask );
13286  }
13287 
13288  VULKAN_HPP_INLINE void CommandBuffer::setStencilWriteMask( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t writeMask ) const VULKAN_HPP_NOEXCEPT
13289  {
13290  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilWriteMask && "Function <vkCmdSetStencilWriteMask> requires <VK_VERSION_1_0>" );
13291 
13292  getDispatcher()->vkCmdSetStencilWriteMask( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkStencilFaceFlags>( faceMask ), writeMask );
13293  }
13294 
13295  VULKAN_HPP_INLINE void CommandBuffer::setStencilReference( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask, uint32_t reference ) const VULKAN_HPP_NOEXCEPT
13296  {
13297  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilReference && "Function <vkCmdSetStencilReference> requires <VK_VERSION_1_0>" );
13298 
13299  getDispatcher()->vkCmdSetStencilReference( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkStencilFaceFlags>( faceMask ), reference );
13300  }
13301 
13302  VULKAN_HPP_INLINE void
13303  CommandBuffer::bindDescriptorSets( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
13304  VULKAN_HPP_NAMESPACE::PipelineLayout layout,
13305  uint32_t firstSet,
13306  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorSet> const & descriptorSets,
13307  VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & dynamicOffsets ) const VULKAN_HPP_NOEXCEPT
13308  {
13309  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindDescriptorSets && "Function <vkCmdBindDescriptorSets> requires <VK_VERSION_1_0>" );
13310 
13311  getDispatcher()->vkCmdBindDescriptorSets( static_cast<VkCommandBuffer>( m_commandBuffer ),
13312  static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
13313  static_cast<VkPipelineLayout>( layout ),
13314  firstSet,
13315  descriptorSets.size(),
13316  reinterpret_cast<const VkDescriptorSet *>( descriptorSets.data() ),
13317  dynamicOffsets.size(),
13318  dynamicOffsets.data() );
13319  }
13320 
13321  VULKAN_HPP_INLINE void CommandBuffer::bindIndexBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer,
13324  {
13325  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindIndexBuffer && "Function <vkCmdBindIndexBuffer> requires <VK_VERSION_1_0>" );
13326 
13327  getDispatcher()->vkCmdBindIndexBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ),
13328  static_cast<VkBuffer>( buffer ),
13329  static_cast<VkDeviceSize>( offset ),
13330  static_cast<VkIndexType>( indexType ) );
13331  }
13332 
13333  VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers( uint32_t firstBinding,
13334  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers,
13335  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets ) const
13336  {
13337  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindVertexBuffers && "Function <vkCmdBindVertexBuffers> requires <VK_VERSION_1_0>" );
13338 # ifdef VULKAN_HPP_NO_EXCEPTIONS
13339  VULKAN_HPP_ASSERT( buffers.size() == offsets.size() );
13340 # else
13341  if ( buffers.size() != offsets.size() )
13342  {
13343  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers: buffers.size() != offsets.size()" );
13344  }
13345 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
13346 
13347  getDispatcher()->vkCmdBindVertexBuffers( static_cast<VkCommandBuffer>( m_commandBuffer ),
13348  firstBinding,
13349  buffers.size(),
13350  reinterpret_cast<const VkBuffer *>( buffers.data() ),
13351  reinterpret_cast<const VkDeviceSize *>( offsets.data() ) );
13352  }
13353 
13354  VULKAN_HPP_INLINE void
13355  CommandBuffer::draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT
13356  {
13357  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDraw && "Function <vkCmdDraw> requires <VK_VERSION_1_0>" );
13358 
13359  getDispatcher()->vkCmdDraw( static_cast<VkCommandBuffer>( m_commandBuffer ), vertexCount, instanceCount, firstVertex, firstInstance );
13360  }
13361 
13362  VULKAN_HPP_INLINE void CommandBuffer::drawIndexed(
13363  uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT
13364  {
13365  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndexed && "Function <vkCmdDrawIndexed> requires <VK_VERSION_1_0>" );
13366 
13367  getDispatcher()->vkCmdDrawIndexed( static_cast<VkCommandBuffer>( m_commandBuffer ), indexCount, instanceCount, firstIndex, vertexOffset, firstInstance );
13368  }
13369 
13370  VULKAN_HPP_INLINE void CommandBuffer::drawIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer,
13372  uint32_t drawCount,
13373  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
13374  {
13375  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndirect && "Function <vkCmdDrawIndirect> requires <VK_VERSION_1_0>" );
13376 
13377  getDispatcher()->vkCmdDrawIndirect(
13378  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
13379  }
13380 
13381  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer,
13383  uint32_t drawCount,
13384  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
13385  {
13386  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndexedIndirect && "Function <vkCmdDrawIndexedIndirect> requires <VK_VERSION_1_0>" );
13387 
13388  getDispatcher()->vkCmdDrawIndexedIndirect(
13389  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
13390  }
13391 
13392  VULKAN_HPP_INLINE void CommandBuffer::dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
13393  {
13394  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatch && "Function <vkCmdDispatch> requires <VK_VERSION_1_0>" );
13395 
13396  getDispatcher()->vkCmdDispatch( static_cast<VkCommandBuffer>( m_commandBuffer ), groupCountX, groupCountY, groupCountZ );
13397  }
13398 
13399  VULKAN_HPP_INLINE void CommandBuffer::dispatchIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer,
13401  {
13402  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatchIndirect && "Function <vkCmdDispatchIndirect> requires <VK_VERSION_1_0>" );
13403 
13404  getDispatcher()->vkCmdDispatchIndirect(
13405  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ) );
13406  }
13407 
13408  VULKAN_HPP_INLINE void
13409  CommandBuffer::copyBuffer( VULKAN_HPP_NAMESPACE::Buffer srcBuffer,
13410  VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
13411  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferCopy> const & regions ) const VULKAN_HPP_NOEXCEPT
13412  {
13413  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyBuffer && "Function <vkCmdCopyBuffer> requires <VK_VERSION_1_0>" );
13414 
13415  getDispatcher()->vkCmdCopyBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ),
13416  static_cast<VkBuffer>( srcBuffer ),
13417  static_cast<VkBuffer>( dstBuffer ),
13418  regions.size(),
13419  reinterpret_cast<const VkBufferCopy *>( regions.data() ) );
13420  }
13421 
13422  VULKAN_HPP_INLINE void
13423  CommandBuffer::copyImage( VULKAN_HPP_NAMESPACE::Image srcImage,
13424  VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
13425  VULKAN_HPP_NAMESPACE::Image dstImage,
13426  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
13427  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageCopy> const & regions ) const VULKAN_HPP_NOEXCEPT
13428  {
13429  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyImage && "Function <vkCmdCopyImage> requires <VK_VERSION_1_0>" );
13430 
13431  getDispatcher()->vkCmdCopyImage( static_cast<VkCommandBuffer>( m_commandBuffer ),
13432  static_cast<VkImage>( srcImage ),
13433  static_cast<VkImageLayout>( srcImageLayout ),
13434  static_cast<VkImage>( dstImage ),
13435  static_cast<VkImageLayout>( dstImageLayout ),
13436  regions.size(),
13437  reinterpret_cast<const VkImageCopy *>( regions.data() ) );
13438  }
13439 
13440  VULKAN_HPP_INLINE void CommandBuffer::blitImage( VULKAN_HPP_NAMESPACE::Image srcImage,
13441  VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
13442  VULKAN_HPP_NAMESPACE::Image dstImage,
13443  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
13444  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageBlit> const & regions,
13446  {
13447  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBlitImage && "Function <vkCmdBlitImage> requires <VK_VERSION_1_0>" );
13448 
13449  getDispatcher()->vkCmdBlitImage( static_cast<VkCommandBuffer>( m_commandBuffer ),
13450  static_cast<VkImage>( srcImage ),
13451  static_cast<VkImageLayout>( srcImageLayout ),
13452  static_cast<VkImage>( dstImage ),
13453  static_cast<VkImageLayout>( dstImageLayout ),
13454  regions.size(),
13455  reinterpret_cast<const VkImageBlit *>( regions.data() ),
13456  static_cast<VkFilter>( filter ) );
13457  }
13458 
13459  VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage(
13460  VULKAN_HPP_NAMESPACE::Buffer srcBuffer,
13461  VULKAN_HPP_NAMESPACE::Image dstImage,
13462  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
13463  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions ) const VULKAN_HPP_NOEXCEPT
13464  {
13465  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyBufferToImage && "Function <vkCmdCopyBufferToImage> requires <VK_VERSION_1_0>" );
13466 
13467  getDispatcher()->vkCmdCopyBufferToImage( static_cast<VkCommandBuffer>( m_commandBuffer ),
13468  static_cast<VkBuffer>( srcBuffer ),
13469  static_cast<VkImage>( dstImage ),
13470  static_cast<VkImageLayout>( dstImageLayout ),
13471  regions.size(),
13472  reinterpret_cast<const VkBufferImageCopy *>( regions.data() ) );
13473  }
13474 
13475  VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer(
13476  VULKAN_HPP_NAMESPACE::Image srcImage,
13477  VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
13478  VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
13479  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferImageCopy> const & regions ) const VULKAN_HPP_NOEXCEPT
13480  {
13481  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyImageToBuffer && "Function <vkCmdCopyImageToBuffer> requires <VK_VERSION_1_0>" );
13482 
13483  getDispatcher()->vkCmdCopyImageToBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ),
13484  static_cast<VkImage>( srcImage ),
13485  static_cast<VkImageLayout>( srcImageLayout ),
13486  static_cast<VkBuffer>( dstBuffer ),
13487  regions.size(),
13488  reinterpret_cast<const VkBufferImageCopy *>( regions.data() ) );
13489  }
13490 
13491  template <typename DataType>
13492  VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
13494  VULKAN_HPP_NAMESPACE::ArrayProxy<const DataType> const & data ) const VULKAN_HPP_NOEXCEPT
13495  {
13496  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdUpdateBuffer && "Function <vkCmdUpdateBuffer> requires <VK_VERSION_1_0>" );
13497 
13498  getDispatcher()->vkCmdUpdateBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ),
13499  static_cast<VkBuffer>( dstBuffer ),
13500  static_cast<VkDeviceSize>( dstOffset ),
13501  data.size() * sizeof( DataType ),
13502  reinterpret_cast<const void *>( data.data() ) );
13503  }
13504 
13505  VULKAN_HPP_INLINE void CommandBuffer::fillBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
13508  uint32_t data ) const VULKAN_HPP_NOEXCEPT
13509  {
13510  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdFillBuffer && "Function <vkCmdFillBuffer> requires <VK_VERSION_1_0>" );
13511 
13512  getDispatcher()->vkCmdFillBuffer( static_cast<VkCommandBuffer>( m_commandBuffer ),
13513  static_cast<VkBuffer>( dstBuffer ),
13514  static_cast<VkDeviceSize>( dstOffset ),
13515  static_cast<VkDeviceSize>( size ),
13516  data );
13517  }
13518 
13519  VULKAN_HPP_INLINE void CommandBuffer::clearColorImage(
13520  VULKAN_HPP_NAMESPACE::Image image,
13522  const VULKAN_HPP_NAMESPACE::ClearColorValue & color,
13523  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges ) const VULKAN_HPP_NOEXCEPT
13524  {
13525  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdClearColorImage && "Function <vkCmdClearColorImage> requires <VK_VERSION_1_0>" );
13526 
13527  getDispatcher()->vkCmdClearColorImage( static_cast<VkCommandBuffer>( m_commandBuffer ),
13528  static_cast<VkImage>( image ),
13529  static_cast<VkImageLayout>( imageLayout ),
13530  reinterpret_cast<const VkClearColorValue *>( &color ),
13531  ranges.size(),
13532  reinterpret_cast<const VkImageSubresourceRange *>( ranges.data() ) );
13533  }
13534 
13535  VULKAN_HPP_INLINE void CommandBuffer::clearDepthStencilImage(
13536  VULKAN_HPP_NAMESPACE::Image image,
13538  const VULKAN_HPP_NAMESPACE::ClearDepthStencilValue & depthStencil,
13539  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceRange> const & ranges ) const VULKAN_HPP_NOEXCEPT
13540  {
13541  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdClearDepthStencilImage && "Function <vkCmdClearDepthStencilImage> requires <VK_VERSION_1_0>" );
13542 
13543  getDispatcher()->vkCmdClearDepthStencilImage( static_cast<VkCommandBuffer>( m_commandBuffer ),
13544  static_cast<VkImage>( image ),
13545  static_cast<VkImageLayout>( imageLayout ),
13546  reinterpret_cast<const VkClearDepthStencilValue *>( &depthStencil ),
13547  ranges.size(),
13548  reinterpret_cast<const VkImageSubresourceRange *>( ranges.data() ) );
13549  }
13550 
13551  VULKAN_HPP_INLINE void
13552  CommandBuffer::clearAttachments( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearAttachment> const & attachments,
13553  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ClearRect> const & rects ) const VULKAN_HPP_NOEXCEPT
13554  {
13555  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdClearAttachments && "Function <vkCmdClearAttachments> requires <VK_VERSION_1_0>" );
13556 
13557  getDispatcher()->vkCmdClearAttachments( static_cast<VkCommandBuffer>( m_commandBuffer ),
13558  attachments.size(),
13559  reinterpret_cast<const VkClearAttachment *>( attachments.data() ),
13560  rects.size(),
13561  reinterpret_cast<const VkClearRect *>( rects.data() ) );
13562  }
13563 
13564  VULKAN_HPP_INLINE void
13565  CommandBuffer::resolveImage( VULKAN_HPP_NAMESPACE::Image srcImage,
13566  VULKAN_HPP_NAMESPACE::ImageLayout srcImageLayout,
13567  VULKAN_HPP_NAMESPACE::Image dstImage,
13568  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
13569  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageResolve> const & regions ) const VULKAN_HPP_NOEXCEPT
13570  {
13571  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdResolveImage && "Function <vkCmdResolveImage> requires <VK_VERSION_1_0>" );
13572 
13573  getDispatcher()->vkCmdResolveImage( static_cast<VkCommandBuffer>( m_commandBuffer ),
13574  static_cast<VkImage>( srcImage ),
13575  static_cast<VkImageLayout>( srcImageLayout ),
13576  static_cast<VkImage>( dstImage ),
13577  static_cast<VkImageLayout>( dstImageLayout ),
13578  regions.size(),
13579  reinterpret_cast<const VkImageResolve *>( regions.data() ) );
13580  }
13581 
13582  VULKAN_HPP_INLINE void CommandBuffer::setEvent( VULKAN_HPP_NAMESPACE::Event event,
13584  {
13585  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetEvent && "Function <vkCmdSetEvent> requires <VK_VERSION_1_0>" );
13586 
13587  getDispatcher()->vkCmdSetEvent(
13588  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) );
13589  }
13590 
13591  VULKAN_HPP_INLINE void CommandBuffer::resetEvent( VULKAN_HPP_NAMESPACE::Event event,
13593  {
13594  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdResetEvent && "Function <vkCmdResetEvent> requires <VK_VERSION_1_0>" );
13595 
13596  getDispatcher()->vkCmdResetEvent(
13597  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) );
13598  }
13599 
13600  VULKAN_HPP_INLINE void CommandBuffer::waitEvents(
13601  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events,
13604  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const & memoryBarriers,
13605  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,
13606  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const & imageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT
13607  {
13608  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWaitEvents && "Function <vkCmdWaitEvents> requires <VK_VERSION_1_0>" );
13609 
13610  getDispatcher()->vkCmdWaitEvents( static_cast<VkCommandBuffer>( m_commandBuffer ),
13611  events.size(),
13612  reinterpret_cast<const VkEvent *>( events.data() ),
13613  static_cast<VkPipelineStageFlags>( srcStageMask ),
13614  static_cast<VkPipelineStageFlags>( dstStageMask ),
13615  memoryBarriers.size(),
13616  reinterpret_cast<const VkMemoryBarrier *>( memoryBarriers.data() ),
13617  bufferMemoryBarriers.size(),
13618  reinterpret_cast<const VkBufferMemoryBarrier *>( bufferMemoryBarriers.data() ),
13619  imageMemoryBarriers.size(),
13620  reinterpret_cast<const VkImageMemoryBarrier *>( imageMemoryBarriers.data() ) );
13621  }
13622 
13623  VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier(
13626  VULKAN_HPP_NAMESPACE::DependencyFlags dependencyFlags,
13627  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MemoryBarrier> const & memoryBarriers,
13628  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier> const & bufferMemoryBarriers,
13629  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier> const & imageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT
13630  {
13631  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPipelineBarrier && "Function <vkCmdPipelineBarrier> requires <VK_VERSION_1_0>" );
13632 
13633  getDispatcher()->vkCmdPipelineBarrier( static_cast<VkCommandBuffer>( m_commandBuffer ),
13634  static_cast<VkPipelineStageFlags>( srcStageMask ),
13635  static_cast<VkPipelineStageFlags>( dstStageMask ),
13636  static_cast<VkDependencyFlags>( dependencyFlags ),
13637  memoryBarriers.size(),
13638  reinterpret_cast<const VkMemoryBarrier *>( memoryBarriers.data() ),
13639  bufferMemoryBarriers.size(),
13640  reinterpret_cast<const VkBufferMemoryBarrier *>( bufferMemoryBarriers.data() ),
13641  imageMemoryBarriers.size(),
13642  reinterpret_cast<const VkImageMemoryBarrier *>( imageMemoryBarriers.data() ) );
13643  }
13644 
13645  VULKAN_HPP_INLINE void CommandBuffer::beginQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
13646  uint32_t query,
13648  {
13649  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginQuery && "Function <vkCmdBeginQuery> requires <VK_VERSION_1_0>" );
13650 
13651  getDispatcher()->vkCmdBeginQuery(
13652  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ) );
13653  }
13654 
13655  VULKAN_HPP_INLINE void CommandBuffer::endQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT
13656  {
13657  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndQuery && "Function <vkCmdEndQuery> requires <VK_VERSION_1_0>" );
13658 
13659  getDispatcher()->vkCmdEndQuery( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkQueryPool>( queryPool ), query );
13660  }
13661 
13662  VULKAN_HPP_INLINE void
13663  CommandBuffer::resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
13664  {
13665  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdResetQueryPool && "Function <vkCmdResetQueryPool> requires <VK_VERSION_1_0>" );
13666 
13667  getDispatcher()->vkCmdResetQueryPool( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount );
13668  }
13669 
13670  VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,
13671  VULKAN_HPP_NAMESPACE::QueryPool queryPool,
13672  uint32_t query ) const VULKAN_HPP_NOEXCEPT
13673  {
13674  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteTimestamp && "Function <vkCmdWriteTimestamp> requires <VK_VERSION_1_0>" );
13675 
13676  getDispatcher()->vkCmdWriteTimestamp(
13677  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPipelineStageFlagBits>( pipelineStage ), static_cast<VkQueryPool>( queryPool ), query );
13678  }
13679 
13680  VULKAN_HPP_INLINE void CommandBuffer::copyQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
13681  uint32_t firstQuery,
13682  uint32_t queryCount,
13683  VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
13687  {
13688  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyQueryPoolResults && "Function <vkCmdCopyQueryPoolResults> requires <VK_VERSION_1_0>" );
13689 
13690  getDispatcher()->vkCmdCopyQueryPoolResults( static_cast<VkCommandBuffer>( m_commandBuffer ),
13691  static_cast<VkQueryPool>( queryPool ),
13692  firstQuery,
13693  queryCount,
13694  static_cast<VkBuffer>( dstBuffer ),
13695  static_cast<VkDeviceSize>( dstOffset ),
13696  static_cast<VkDeviceSize>( stride ),
13697  static_cast<VkQueryResultFlags>( flags ) );
13698  }
13699 
13700  template <typename ValuesType>
13701  VULKAN_HPP_INLINE void CommandBuffer::pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout layout,
13703  uint32_t offset,
13704  VULKAN_HPP_NAMESPACE::ArrayProxy<const ValuesType> const & values ) const VULKAN_HPP_NOEXCEPT
13705  {
13706  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushConstants && "Function <vkCmdPushConstants> requires <VK_VERSION_1_0>" );
13707 
13708  getDispatcher()->vkCmdPushConstants( static_cast<VkCommandBuffer>( m_commandBuffer ),
13709  static_cast<VkPipelineLayout>( layout ),
13710  static_cast<VkShaderStageFlags>( stageFlags ),
13711  offset,
13712  values.size() * sizeof( ValuesType ),
13713  reinterpret_cast<const void *>( values.data() ) );
13714  }
13715 
13716  VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,
13718  {
13719  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginRenderPass && "Function <vkCmdBeginRenderPass> requires <VK_VERSION_1_0>" );
13720 
13721  getDispatcher()->vkCmdBeginRenderPass( static_cast<VkCommandBuffer>( m_commandBuffer ),
13722  reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ),
13723  static_cast<VkSubpassContents>( contents ) );
13724  }
13725 
13726  VULKAN_HPP_INLINE void CommandBuffer::nextSubpass( VULKAN_HPP_NAMESPACE::SubpassContents contents ) const VULKAN_HPP_NOEXCEPT
13727  {
13728  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdNextSubpass && "Function <vkCmdNextSubpass> requires <VK_VERSION_1_0>" );
13729 
13730  getDispatcher()->vkCmdNextSubpass( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkSubpassContents>( contents ) );
13731  }
13732 
13733  VULKAN_HPP_INLINE void CommandBuffer::endRenderPass() const VULKAN_HPP_NOEXCEPT
13734  {
13735  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndRenderPass && "Function <vkCmdEndRenderPass> requires <VK_VERSION_1_0>" );
13736 
13737  getDispatcher()->vkCmdEndRenderPass( static_cast<VkCommandBuffer>( m_commandBuffer ) );
13738  }
13739 
13740  VULKAN_HPP_INLINE void CommandBuffer::executeCommands(
13741  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CommandBuffer> const & commandBuffers ) const VULKAN_HPP_NOEXCEPT
13742  {
13743  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdExecuteCommands && "Function <vkCmdExecuteCommands> requires <VK_VERSION_1_0>" );
13744 
13745  getDispatcher()->vkCmdExecuteCommands(
13746  static_cast<VkCommandBuffer>( m_commandBuffer ), commandBuffers.size(), reinterpret_cast<const VkCommandBuffer *>( commandBuffers.data() ) );
13747  }
13748 
13749  //=== VK_VERSION_1_1 ===
13750 
13752  {
13753  VULKAN_HPP_ASSERT( getDispatcher()->vkEnumerateInstanceVersion && "Function <vkEnumerateInstanceVersion> requires <VK_VERSION_1_1>" );
13754 
13755  uint32_t apiVersion;
13756  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumerateInstanceVersion( &apiVersion ) );
13757  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Context::enumerateInstanceVersion" );
13758 
13759  return apiVersion;
13760  }
13761 
13762  VULKAN_HPP_INLINE void
13763  Device::bindBufferMemory2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos ) const
13764  {
13765  VULKAN_HPP_ASSERT( getDispatcher()->vkBindBufferMemory2 && "Function <vkBindBufferMemory2> requires <VK_KHR_bind_memory2> or <VK_VERSION_1_1>" );
13766 
13767  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkBindBufferMemory2(
13768  static_cast<VkDevice>( m_device ), bindInfos.size(), reinterpret_cast<const VkBindBufferMemoryInfo *>( bindInfos.data() ) ) );
13769  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory2" );
13770  }
13771 
13772  VULKAN_HPP_INLINE void Device::bindImageMemory2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos ) const
13773  {
13774  VULKAN_HPP_ASSERT( getDispatcher()->vkBindImageMemory2 && "Function <vkBindImageMemory2> requires <VK_KHR_bind_memory2> or <VK_VERSION_1_1>" );
13775 
13776  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkBindImageMemory2(
13777  static_cast<VkDevice>( m_device ), bindInfos.size(), reinterpret_cast<const VkBindImageMemoryInfo *>( bindInfos.data() ) ) );
13778  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory2" );
13779  }
13780 
13782  Device::getGroupPeerMemoryFeatures( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex ) const VULKAN_HPP_NOEXCEPT
13783  {
13785  "Function <vkGetDeviceGroupPeerMemoryFeatures> requires <VK_KHR_device_group> or <VK_VERSION_1_1>" );
13786 
13788  getDispatcher()->vkGetDeviceGroupPeerMemoryFeatures( static_cast<VkDevice>( m_device ),
13789  heapIndex,
13790  localDeviceIndex,
13791  remoteDeviceIndex,
13792  reinterpret_cast<VkPeerMemoryFeatureFlags *>( &peerMemoryFeatures ) );
13793 
13794  return peerMemoryFeatures;
13795  }
13796 
13797  VULKAN_HPP_INLINE void CommandBuffer::setDeviceMask( uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT
13798  {
13799  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDeviceMask && "Function <vkCmdSetDeviceMask> requires <VK_KHR_device_group> or <VK_VERSION_1_1>" );
13800 
13801  getDispatcher()->vkCmdSetDeviceMask( static_cast<VkCommandBuffer>( m_commandBuffer ), deviceMask );
13802  }
13803 
13804  VULKAN_HPP_INLINE void CommandBuffer::dispatchBase( uint32_t baseGroupX,
13805  uint32_t baseGroupY,
13806  uint32_t baseGroupZ,
13807  uint32_t groupCountX,
13808  uint32_t groupCountY,
13809  uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
13810  {
13811  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatchBase && "Function <vkCmdDispatchBase> requires <VK_KHR_device_group> or <VK_VERSION_1_1>" );
13812 
13813  getDispatcher()->vkCmdDispatchBase(
13814  static_cast<VkCommandBuffer>( m_commandBuffer ), baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
13815  }
13816 
13817  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> Instance::enumeratePhysicalDeviceGroups() const
13818  {
13820  "Function <vkEnumeratePhysicalDeviceGroups> requires <VK_KHR_device_group_creation> or <VK_VERSION_1_1>" );
13821 
13822  std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> physicalDeviceGroupProperties;
13823  uint32_t physicalDeviceGroupCount;
13825  do
13826  {
13827  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
13828  getDispatcher()->vkEnumeratePhysicalDeviceGroups( static_cast<VkInstance>( m_instance ), &physicalDeviceGroupCount, nullptr ) );
13829  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && physicalDeviceGroupCount )
13830  {
13831  physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
13832  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
13833  getDispatcher()->vkEnumeratePhysicalDeviceGroups( static_cast<VkInstance>( m_instance ),
13834  &physicalDeviceGroupCount,
13835  reinterpret_cast<VkPhysicalDeviceGroupProperties *>( physicalDeviceGroupProperties.data() ) ) );
13836  }
13837  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
13838  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroups" );
13839  VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() );
13840  if ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() )
13841  {
13842  physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
13843  }
13844  return physicalDeviceGroupProperties;
13845  }
13846 
13847  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2
13848  Device::getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT
13849  {
13851  "Function <vkGetImageMemoryRequirements2> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" );
13852 
13853  VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
13854  getDispatcher()->vkGetImageMemoryRequirements2( static_cast<VkDevice>( m_device ),
13855  reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ),
13856  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
13857 
13858  return memoryRequirements;
13859  }
13860 
13861  template <typename X, typename Y, typename... Z>
13862  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
13863  Device::getImageMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT
13864  {
13866  "Function <vkGetImageMemoryRequirements2> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" );
13867 
13868  VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
13869  VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
13870  getDispatcher()->vkGetImageMemoryRequirements2( static_cast<VkDevice>( m_device ),
13871  reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ),
13872  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
13873 
13874  return structureChain;
13875  }
13876 
13877  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2
13878  Device::getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT
13879  {
13881  "Function <vkGetBufferMemoryRequirements2> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" );
13882 
13883  VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
13884  getDispatcher()->vkGetBufferMemoryRequirements2( static_cast<VkDevice>( m_device ),
13885  reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ),
13886  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
13887 
13888  return memoryRequirements;
13889  }
13890 
13891  template <typename X, typename Y, typename... Z>
13892  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
13893  Device::getBufferMemoryRequirements2( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT
13894  {
13896  "Function <vkGetBufferMemoryRequirements2> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" );
13897 
13898  VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
13899  VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
13900  getDispatcher()->vkGetBufferMemoryRequirements2( static_cast<VkDevice>( m_device ),
13901  reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ),
13902  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
13903 
13904  return structureChain;
13905  }
13906 
13907  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>
13908  Device::getImageSparseMemoryRequirements2( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info ) const
13909  {
13911  "Function <vkGetImageSparseMemoryRequirements2> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" );
13912 
13913  std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> sparseMemoryRequirements;
13914  uint32_t sparseMemoryRequirementCount;
13915  getDispatcher()->vkGetImageSparseMemoryRequirements2(
13916  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), &sparseMemoryRequirementCount, nullptr );
13917  sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
13918  getDispatcher()->vkGetImageSparseMemoryRequirements2( static_cast<VkDevice>( m_device ),
13919  reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
13920  &sparseMemoryRequirementCount,
13921  reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
13922 
13923  VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
13924  if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() )
13925  {
13926  sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
13927  }
13928  return sparseMemoryRequirements;
13929  }
13930 
13931  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 PhysicalDevice::getFeatures2() const VULKAN_HPP_NOEXCEPT
13932  {
13933  VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFeatures2 &&
13934  "Function <vkGetPhysicalDeviceFeatures2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
13935 
13936  VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 features;
13937  getDispatcher()->vkGetPhysicalDeviceFeatures2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
13938  reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) );
13939 
13940  return features;
13941  }
13942 
13943  template <typename X, typename Y, typename... Z>
13944  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> PhysicalDevice::getFeatures2() const VULKAN_HPP_NOEXCEPT
13945  {
13946  VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFeatures2 &&
13947  "Function <vkGetPhysicalDeviceFeatures2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
13948 
13949  VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
13950  VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 & features = structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2>();
13951  getDispatcher()->vkGetPhysicalDeviceFeatures2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
13952  reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) );
13953 
13954  return structureChain;
13955  }
13956 
13957  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 PhysicalDevice::getProperties2() const VULKAN_HPP_NOEXCEPT
13958  {
13960  "Function <vkGetPhysicalDeviceProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
13961 
13962  VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 properties;
13963  getDispatcher()->vkGetPhysicalDeviceProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
13964  reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) );
13965 
13966  return properties;
13967  }
13968 
13969  template <typename X, typename Y, typename... Z>
13970  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> PhysicalDevice::getProperties2() const VULKAN_HPP_NOEXCEPT
13971  {
13973  "Function <vkGetPhysicalDeviceProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
13974 
13975  VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
13976  VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 & properties = structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2>();
13977  getDispatcher()->vkGetPhysicalDeviceProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
13978  reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) );
13979 
13980  return structureChain;
13981  }
13982 
13983  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::FormatProperties2
13984  PhysicalDevice::getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT
13985  {
13987  "Function <vkGetPhysicalDeviceFormatProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
13988 
13989  VULKAN_HPP_NAMESPACE::FormatProperties2 formatProperties;
13990  getDispatcher()->vkGetPhysicalDeviceFormatProperties2(
13991  static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) );
13992 
13993  return formatProperties;
13994  }
13995 
13996  template <typename X, typename Y, typename... Z>
13997  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
13998  PhysicalDevice::getFormatProperties2( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT
13999  {
14001  "Function <vkGetPhysicalDeviceFormatProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
14002 
14003  VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
14004  VULKAN_HPP_NAMESPACE::FormatProperties2 & formatProperties = structureChain.template get<VULKAN_HPP_NAMESPACE::FormatProperties2>();
14005  getDispatcher()->vkGetPhysicalDeviceFormatProperties2(
14006  static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) );
14007 
14008  return structureChain;
14009  }
14010 
14011  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ImageFormatProperties2
14012  PhysicalDevice::getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const
14013  {
14015  "Function <vkGetPhysicalDeviceImageFormatProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
14016 
14017  VULKAN_HPP_NAMESPACE::ImageFormatProperties2 imageFormatProperties;
14019  getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14020  reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ),
14021  reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) );
14022  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" );
14023 
14024  return imageFormatProperties;
14025  }
14026 
14027  template <typename X, typename Y, typename... Z>
14028  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
14029  PhysicalDevice::getImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const
14030  {
14032  "Function <vkGetPhysicalDeviceImageFormatProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
14033 
14034  StructureChain<X, Y, Z...> structureChain;
14035  VULKAN_HPP_NAMESPACE::ImageFormatProperties2 & imageFormatProperties = structureChain.template get<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>();
14037  getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14038  reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ),
14039  reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) );
14040  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" );
14041 
14042  return structureChain;
14043  }
14044 
14045  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> PhysicalDevice::getQueueFamilyProperties2() const
14046  {
14048  "Function <vkGetPhysicalDeviceQueueFamilyProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
14049 
14050  std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties;
14051  uint32_t queueFamilyPropertyCount;
14052  getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ), &queueFamilyPropertyCount, nullptr );
14053  queueFamilyProperties.resize( queueFamilyPropertyCount );
14054  getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14055  &queueFamilyPropertyCount,
14056  reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
14057 
14058  VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
14059  if ( queueFamilyPropertyCount < queueFamilyProperties.size() )
14060  {
14061  queueFamilyProperties.resize( queueFamilyPropertyCount );
14062  }
14063  return queueFamilyProperties;
14064  }
14065 
14066  template <typename StructureChain>
14067  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain> PhysicalDevice::getQueueFamilyProperties2() const
14068  {
14070  "Function <vkGetPhysicalDeviceQueueFamilyProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
14071 
14072  std::vector<StructureChain> structureChains;
14073  std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties;
14074  uint32_t queueFamilyPropertyCount;
14075  getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ), &queueFamilyPropertyCount, nullptr );
14076  structureChains.resize( queueFamilyPropertyCount );
14077  queueFamilyProperties.resize( queueFamilyPropertyCount );
14078  for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
14079  {
14080  queueFamilyProperties[i].pNext = structureChains[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext;
14081  }
14082  getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14083  &queueFamilyPropertyCount,
14084  reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
14085 
14086  VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
14087  if ( queueFamilyPropertyCount < queueFamilyProperties.size() )
14088  {
14089  structureChains.resize( queueFamilyPropertyCount );
14090  }
14091  for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
14092  {
14093  structureChains[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = queueFamilyProperties[i];
14094  }
14095  return structureChains;
14096  }
14097 
14098  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2
14099  PhysicalDevice::getMemoryProperties2() const VULKAN_HPP_NOEXCEPT
14100  {
14102  "Function <vkGetPhysicalDeviceMemoryProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
14103 
14104  VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 memoryProperties;
14105  getDispatcher()->vkGetPhysicalDeviceMemoryProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14106  reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) );
14107 
14108  return memoryProperties;
14109  }
14110 
14111  template <typename X, typename Y, typename... Z>
14112  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> PhysicalDevice::getMemoryProperties2() const VULKAN_HPP_NOEXCEPT
14113  {
14115  "Function <vkGetPhysicalDeviceMemoryProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
14116 
14117  VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
14118  VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 & memoryProperties =
14119  structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2>();
14120  getDispatcher()->vkGetPhysicalDeviceMemoryProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14121  reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) );
14122 
14123  return structureChain;
14124  }
14125 
14126  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>
14127  PhysicalDevice::getSparseImageFormatProperties2( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo ) const
14128  {
14130  "Function <vkGetPhysicalDeviceSparseImageFormatProperties2> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
14131 
14132  std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2> properties;
14133  uint32_t propertyCount;
14134  getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14135  reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
14136  &propertyCount,
14137  nullptr );
14138  properties.resize( propertyCount );
14139  getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14140  reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
14141  &propertyCount,
14142  reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) );
14143 
14144  VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
14145  if ( propertyCount < properties.size() )
14146  {
14147  properties.resize( propertyCount );
14148  }
14149  return properties;
14150  }
14151 
14153  {
14154  VULKAN_HPP_ASSERT( getDispatcher()->vkTrimCommandPool && "Function <vkTrimCommandPool> requires <VK_KHR_maintenance1> or <VK_VERSION_1_1>" );
14155 
14156  getDispatcher()->vkTrimCommandPool(
14157  static_cast<VkDevice>( m_device ), static_cast<VkCommandPool>( m_commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
14158  }
14159 
14161  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Queue>::Type
14162  Device::getQueue2( VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 const & queueInfo ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT
14163  {
14164  VULKAN_HPP_NAMESPACE::Queue queue;
14165  getDispatcher()->vkGetDeviceQueue2(
14166  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDeviceQueueInfo2 *>( &queueInfo ), reinterpret_cast<VkQueue *>( &queue ) );
14167 
14168  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Queue( *this, *reinterpret_cast<VkQueue *>( &queue ) );
14169  }
14170 
14172  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion>::Type
14173  Device::createSamplerYcbcrConversion( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & createInfo,
14174  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
14176  {
14177  VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion;
14178  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateSamplerYcbcrConversion(
14179  static_cast<VkDevice>( m_device ),
14180  reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( &createInfo ),
14181  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
14182  reinterpret_cast<VkSamplerYcbcrConversion *>( &ycbcrConversion ) ) );
14183  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
14184  {
14185 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
14186  return VULKAN_HPP_UNEXPECTED( result );
14187 # else
14188  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createSamplerYcbcrConversion" );
14189 # endif
14190  }
14191 
14192  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion(
14193  *this, *reinterpret_cast<VkSamplerYcbcrConversion *>( &ycbcrConversion ), allocator );
14194  }
14195 
14197  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate>::Type
14198  Device::createDescriptorUpdateTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & createInfo,
14199  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
14201  {
14202  VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate;
14203  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateDescriptorUpdateTemplate(
14204  static_cast<VkDevice>( m_device ),
14205  reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo *>( &createInfo ),
14206  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
14207  reinterpret_cast<VkDescriptorUpdateTemplate *>( &descriptorUpdateTemplate ) ) );
14208  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
14209  {
14210 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
14211  return VULKAN_HPP_UNEXPECTED( result );
14212 # else
14213  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createDescriptorUpdateTemplate" );
14214 # endif
14215  }
14216 
14217  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate(
14218  *this, *reinterpret_cast<VkDescriptorUpdateTemplate *>( &descriptorUpdateTemplate ), allocator );
14219  }
14220 
14221  template <typename DataType>
14222  VULKAN_HPP_INLINE void DescriptorSet::updateWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
14223  DataType const & data ) const VULKAN_HPP_NOEXCEPT
14224  {
14226  "Function <vkUpdateDescriptorSetWithTemplate> requires <VK_KHR_descriptor_update_template> or <VK_VERSION_1_1>" );
14227 
14228  getDispatcher()->vkUpdateDescriptorSetWithTemplate( static_cast<VkDevice>( m_device ),
14229  static_cast<VkDescriptorSet>( m_descriptorSet ),
14230  static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
14231  reinterpret_cast<const void *>( &data ) );
14232  }
14233 
14234  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalBufferProperties
14235  PhysicalDevice::getExternalBufferProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo ) const VULKAN_HPP_NOEXCEPT
14236  {
14238  "Function <vkGetPhysicalDeviceExternalBufferProperties> requires <VK_KHR_external_memory_capabilities> or <VK_VERSION_1_1>" );
14239 
14240  VULKAN_HPP_NAMESPACE::ExternalBufferProperties externalBufferProperties;
14241  getDispatcher()->vkGetPhysicalDeviceExternalBufferProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14242  reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>( &externalBufferInfo ),
14243  reinterpret_cast<VkExternalBufferProperties *>( &externalBufferProperties ) );
14244 
14245  return externalBufferProperties;
14246  }
14247 
14248  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalFenceProperties
14249  PhysicalDevice::getExternalFenceProperties( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo ) const VULKAN_HPP_NOEXCEPT
14250  {
14252  "Function <vkGetPhysicalDeviceExternalFenceProperties> requires <VK_KHR_external_fence_capabilities> or <VK_VERSION_1_1>" );
14253 
14254  VULKAN_HPP_NAMESPACE::ExternalFenceProperties externalFenceProperties;
14255  getDispatcher()->vkGetPhysicalDeviceExternalFenceProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14256  reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>( &externalFenceInfo ),
14257  reinterpret_cast<VkExternalFenceProperties *>( &externalFenceProperties ) );
14258 
14259  return externalFenceProperties;
14260  }
14261 
14262  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties PhysicalDevice::getExternalSemaphoreProperties(
14263  const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT
14264  {
14266  "Function <vkGetPhysicalDeviceExternalSemaphoreProperties> requires <VK_KHR_external_semaphore_capabilities> or <VK_VERSION_1_1>" );
14267 
14268  VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties externalSemaphoreProperties;
14269  getDispatcher()->vkGetPhysicalDeviceExternalSemaphoreProperties(
14270  static_cast<VkPhysicalDevice>( m_physicalDevice ),
14271  reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>( &externalSemaphoreInfo ),
14272  reinterpret_cast<VkExternalSemaphoreProperties *>( &externalSemaphoreProperties ) );
14273 
14274  return externalSemaphoreProperties;
14275  }
14276 
14277  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport
14278  Device::getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT
14279  {
14281  "Function <vkGetDescriptorSetLayoutSupport> requires <VK_KHR_maintenance3> or <VK_VERSION_1_1>" );
14282 
14283  VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport support;
14284  getDispatcher()->vkGetDescriptorSetLayoutSupport( static_cast<VkDevice>( m_device ),
14285  reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
14286  reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) );
14287 
14288  return support;
14289  }
14290 
14291  template <typename X, typename Y, typename... Z>
14292  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
14293  Device::getDescriptorSetLayoutSupport( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT
14294  {
14296  "Function <vkGetDescriptorSetLayoutSupport> requires <VK_KHR_maintenance3> or <VK_VERSION_1_1>" );
14297 
14298  VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
14299  VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport & support = structureChain.template get<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport>();
14300  getDispatcher()->vkGetDescriptorSetLayoutSupport( static_cast<VkDevice>( m_device ),
14301  reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
14302  reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) );
14303 
14304  return structureChain;
14305  }
14306 
14307  //=== VK_VERSION_1_2 ===
14308 
14309  VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer,
14311  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
14312  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
14313  uint32_t maxDrawCount,
14314  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
14315  {
14316  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndirectCount &&
14317  "Function <vkCmdDrawIndirectCount> requires <VK_AMD_draw_indirect_count> or <VK_KHR_draw_indirect_count> or <VK_VERSION_1_2>" );
14318 
14319  getDispatcher()->vkCmdDrawIndirectCount( static_cast<VkCommandBuffer>( m_commandBuffer ),
14320  static_cast<VkBuffer>( buffer ),
14321  static_cast<VkDeviceSize>( offset ),
14322  static_cast<VkBuffer>( countBuffer ),
14323  static_cast<VkDeviceSize>( countBufferOffset ),
14324  maxDrawCount,
14325  stride );
14326  }
14327 
14328  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer,
14330  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
14331  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
14332  uint32_t maxDrawCount,
14333  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
14334  {
14336  "Function <vkCmdDrawIndexedIndirectCount> requires <VK_AMD_draw_indirect_count> or <VK_KHR_draw_indirect_count> or <VK_VERSION_1_2>" );
14337 
14338  getDispatcher()->vkCmdDrawIndexedIndirectCount( static_cast<VkCommandBuffer>( m_commandBuffer ),
14339  static_cast<VkBuffer>( buffer ),
14340  static_cast<VkDeviceSize>( offset ),
14341  static_cast<VkBuffer>( countBuffer ),
14342  static_cast<VkDeviceSize>( countBufferOffset ),
14343  maxDrawCount,
14344  stride );
14345  }
14346 
14348  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::RenderPass>::Type
14349  Device::createRenderPass2( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & createInfo,
14350  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
14352  {
14353  VULKAN_HPP_NAMESPACE::RenderPass renderPass;
14354  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateRenderPass2(
14355  static_cast<VkDevice>( m_device ),
14356  reinterpret_cast<const VkRenderPassCreateInfo2 *>( &createInfo ),
14357  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
14358  reinterpret_cast<VkRenderPass *>( &renderPass ) ) );
14359  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
14360  {
14361 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
14362  return VULKAN_HPP_UNEXPECTED( result );
14363 # else
14364  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createRenderPass2" );
14365 # endif
14366  }
14367 
14368  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::RenderPass( *this, *reinterpret_cast<VkRenderPass *>( &renderPass ), allocator );
14369  }
14370 
14371  VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,
14372  const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT
14373  {
14374  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginRenderPass2 &&
14375  "Function <vkCmdBeginRenderPass2> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" );
14376 
14377  getDispatcher()->vkCmdBeginRenderPass2( static_cast<VkCommandBuffer>( m_commandBuffer ),
14378  reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ),
14379  reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ) );
14380  }
14381 
14382  VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo,
14383  const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT
14384  {
14385  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdNextSubpass2 && "Function <vkCmdNextSubpass2> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" );
14386 
14387  getDispatcher()->vkCmdNextSubpass2( static_cast<VkCommandBuffer>( m_commandBuffer ),
14388  reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ),
14389  reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) );
14390  }
14391 
14392  VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT
14393  {
14394  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndRenderPass2 && "Function <vkCmdEndRenderPass2> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" );
14395 
14396  getDispatcher()->vkCmdEndRenderPass2( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) );
14397  }
14398 
14399  VULKAN_HPP_INLINE void QueryPool::reset( uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
14400  {
14401  VULKAN_HPP_ASSERT( getDispatcher()->vkResetQueryPool && "Function <vkResetQueryPool> requires <VK_EXT_host_query_reset> or <VK_VERSION_1_2>" );
14402 
14403  getDispatcher()->vkResetQueryPool( static_cast<VkDevice>( m_device ), static_cast<VkQueryPool>( m_queryPool ), firstQuery, queryCount );
14404  }
14405 
14406  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Semaphore::getCounterValue() const
14407  {
14408  VULKAN_HPP_ASSERT( getDispatcher()->vkGetSemaphoreCounterValue &&
14409  "Function <vkGetSemaphoreCounterValue> requires <VK_KHR_timeline_semaphore> or <VK_VERSION_1_2>" );
14410 
14411  uint64_t value;
14413  getDispatcher()->vkGetSemaphoreCounterValue( static_cast<VkDevice>( m_device ), static_cast<VkSemaphore>( m_semaphore ), &value ) );
14414  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Semaphore::getCounterValue" );
14415 
14416  return value;
14417  }
14418 
14419  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Device::waitSemaphores( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo,
14420  uint64_t timeout ) const
14421  {
14422  VULKAN_HPP_ASSERT( getDispatcher()->vkWaitSemaphores && "Function <vkWaitSemaphores> requires <VK_KHR_timeline_semaphore> or <VK_VERSION_1_2>" );
14423 
14425  getDispatcher()->vkWaitSemaphores( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreWaitInfo *>( &waitInfo ), timeout ) );
14426  resultCheck(
14427  result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphores", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout } );
14428 
14429  return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
14430  }
14431 
14432  VULKAN_HPP_INLINE void Device::signalSemaphore( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo ) const
14433  {
14434  VULKAN_HPP_ASSERT( getDispatcher()->vkSignalSemaphore && "Function <vkSignalSemaphore> requires <VK_KHR_timeline_semaphore> or <VK_VERSION_1_2>" );
14435 
14437  getDispatcher()->vkSignalSemaphore( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreSignalInfo *>( &signalInfo ) ) );
14438  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::signalSemaphore" );
14439  }
14440 
14442  Device::getBufferAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT
14443  {
14444  VULKAN_HPP_ASSERT( getDispatcher()->vkGetBufferDeviceAddress &&
14445  "Function <vkGetBufferDeviceAddress> requires <VK_EXT_buffer_device_address> or <VK_KHR_buffer_device_address> or <VK_VERSION_1_2>" );
14446 
14447  VkDeviceAddress result =
14448  getDispatcher()->vkGetBufferDeviceAddress( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
14449 
14450  return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>( result );
14451  }
14452 
14454  Device::getBufferOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT
14455  {
14457  "Function <vkGetBufferOpaqueCaptureAddress> requires <VK_KHR_buffer_device_address> or <VK_VERSION_1_2>" );
14458 
14459  uint64_t result =
14460  getDispatcher()->vkGetBufferOpaqueCaptureAddress( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
14461 
14462  return result;
14463  }
14464 
14466  Device::getMemoryOpaqueCaptureAddress( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info ) const VULKAN_HPP_NOEXCEPT
14467  {
14469  "Function <vkGetDeviceMemoryOpaqueCaptureAddress> requires <VK_KHR_buffer_device_address> or <VK_VERSION_1_2>" );
14470 
14471  uint64_t result = getDispatcher()->vkGetDeviceMemoryOpaqueCaptureAddress( static_cast<VkDevice>( m_device ),
14472  reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( &info ) );
14473 
14474  return result;
14475  }
14476 
14477  //=== VK_VERSION_1_3 ===
14478 
14479  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties> PhysicalDevice::getToolProperties() const
14480  {
14482  "Function <vkGetPhysicalDeviceToolProperties> requires <VK_EXT_tooling_info> or <VK_VERSION_1_3>" );
14483 
14484  std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties> toolProperties;
14485  uint32_t toolCount;
14487  do
14488  {
14489  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
14490  getDispatcher()->vkGetPhysicalDeviceToolProperties( static_cast<VkPhysicalDevice>( m_physicalDevice ), &toolCount, nullptr ) );
14491  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && toolCount )
14492  {
14493  toolProperties.resize( toolCount );
14494  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceToolProperties(
14495  static_cast<VkPhysicalDevice>( m_physicalDevice ), &toolCount, reinterpret_cast<VkPhysicalDeviceToolProperties *>( toolProperties.data() ) ) );
14496  }
14497  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
14498  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolProperties" );
14499  VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() );
14500  if ( toolCount < toolProperties.size() )
14501  {
14502  toolProperties.resize( toolCount );
14503  }
14504  return toolProperties;
14505  }
14506 
14508  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PrivateDataSlot>::Type
14509  Device::createPrivateDataSlot( VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo const & createInfo,
14510  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
14512  {
14513  VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot;
14514  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreatePrivateDataSlot(
14515  static_cast<VkDevice>( m_device ),
14516  reinterpret_cast<const VkPrivateDataSlotCreateInfo *>( &createInfo ),
14517  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
14518  reinterpret_cast<VkPrivateDataSlot *>( &privateDataSlot ) ) );
14519  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
14520  {
14521 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
14522  return VULKAN_HPP_UNEXPECTED( result );
14523 # else
14524  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createPrivateDataSlot" );
14525 # endif
14526  }
14527 
14528  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PrivateDataSlot( *this, *reinterpret_cast<VkPrivateDataSlot *>( &privateDataSlot ), allocator );
14529  }
14530 
14531  VULKAN_HPP_INLINE void Device::setPrivateData( VULKAN_HPP_NAMESPACE::ObjectType objectType_,
14532  uint64_t objectHandle,
14533  VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
14534  uint64_t data ) const
14535  {
14536  VULKAN_HPP_ASSERT( getDispatcher()->vkSetPrivateData && "Function <vkSetPrivateData> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" );
14537 
14538  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkSetPrivateData(
14539  static_cast<VkDevice>( m_device ), static_cast<VkObjectType>( objectType_ ), objectHandle, static_cast<VkPrivateDataSlot>( privateDataSlot ), data ) );
14540  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setPrivateData" );
14541  }
14542 
14543  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Device::getPrivateData( VULKAN_HPP_NAMESPACE::ObjectType objectType_,
14544  uint64_t objectHandle,
14545  VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot ) const VULKAN_HPP_NOEXCEPT
14546  {
14547  VULKAN_HPP_ASSERT( getDispatcher()->vkGetPrivateData && "Function <vkGetPrivateData> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" );
14548 
14549  uint64_t data;
14550  getDispatcher()->vkGetPrivateData(
14551  static_cast<VkDevice>( m_device ), static_cast<VkObjectType>( objectType_ ), objectHandle, static_cast<VkPrivateDataSlot>( privateDataSlot ), &data );
14552 
14553  return data;
14554  }
14555 
14556  VULKAN_HPP_INLINE void CommandBuffer::setEvent2( VULKAN_HPP_NAMESPACE::Event event,
14557  const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT
14558  {
14559  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetEvent2 && "Function <vkCmdSetEvent2> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" );
14560 
14561  getDispatcher()->vkCmdSetEvent2(
14562  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkEvent>( event ), reinterpret_cast<const VkDependencyInfo *>( &dependencyInfo ) );
14563  }
14564 
14565  VULKAN_HPP_INLINE void CommandBuffer::resetEvent2( VULKAN_HPP_NAMESPACE::Event event,
14567  {
14568  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdResetEvent2 && "Function <vkCmdResetEvent2> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" );
14569 
14570  getDispatcher()->vkCmdResetEvent2(
14571  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags2>( stageMask ) );
14572  }
14573 
14574  VULKAN_HPP_INLINE void
14575  CommandBuffer::waitEvents2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events,
14576  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfo> const & dependencyInfos ) const
14577  {
14578  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWaitEvents2 && "Function <vkCmdWaitEvents2> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" );
14579 # ifdef VULKAN_HPP_NO_EXCEPTIONS
14580  VULKAN_HPP_ASSERT( events.size() == dependencyInfos.size() );
14581 # else
14582  if ( events.size() != dependencyInfos.size() )
14583  {
14584  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::waitEvents2: events.size() != dependencyInfos.size()" );
14585  }
14586 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
14587 
14588  getDispatcher()->vkCmdWaitEvents2( static_cast<VkCommandBuffer>( m_commandBuffer ),
14589  events.size(),
14590  reinterpret_cast<const VkEvent *>( events.data() ),
14591  reinterpret_cast<const VkDependencyInfo *>( dependencyInfos.data() ) );
14592  }
14593 
14594  VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier2( const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT
14595  {
14596  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPipelineBarrier2 && "Function <vkCmdPipelineBarrier2> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" );
14597 
14598  getDispatcher()->vkCmdPipelineBarrier2( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkDependencyInfo *>( &dependencyInfo ) );
14599  }
14600 
14601  VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp2( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage,
14602  VULKAN_HPP_NAMESPACE::QueryPool queryPool,
14603  uint32_t query ) const VULKAN_HPP_NOEXCEPT
14604  {
14605  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteTimestamp2 && "Function <vkCmdWriteTimestamp2> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" );
14606 
14607  getDispatcher()->vkCmdWriteTimestamp2(
14608  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPipelineStageFlags2>( stage ), static_cast<VkQueryPool>( queryPool ), query );
14609  }
14610 
14611  VULKAN_HPP_INLINE void Queue::submit2( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2> const & submits,
14612  VULKAN_HPP_NAMESPACE::Fence fence ) const
14613  {
14614  VULKAN_HPP_ASSERT( getDispatcher()->vkQueueSubmit2 && "Function <vkQueueSubmit2> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" );
14615 
14616  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkQueueSubmit2(
14617  static_cast<VkQueue>( m_queue ), submits.size(), reinterpret_cast<const VkSubmitInfo2 *>( submits.data() ), static_cast<VkFence>( fence ) ) );
14618  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::submit2" );
14619  }
14620 
14621  VULKAN_HPP_INLINE void CommandBuffer::copyBuffer2( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo ) const VULKAN_HPP_NOEXCEPT
14622  {
14623  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyBuffer2 && "Function <vkCmdCopyBuffer2> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" );
14624 
14625  getDispatcher()->vkCmdCopyBuffer2( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCopyBufferInfo2 *>( &copyBufferInfo ) );
14626  }
14627 
14628  VULKAN_HPP_INLINE void CommandBuffer::copyImage2( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo ) const VULKAN_HPP_NOEXCEPT
14629  {
14630  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyImage2 && "Function <vkCmdCopyImage2> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" );
14631 
14632  getDispatcher()->vkCmdCopyImage2( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCopyImageInfo2 *>( &copyImageInfo ) );
14633  }
14634 
14635  VULKAN_HPP_INLINE void
14636  CommandBuffer::copyBufferToImage2( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT
14637  {
14638  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyBufferToImage2 &&
14639  "Function <vkCmdCopyBufferToImage2> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" );
14640 
14641  getDispatcher()->vkCmdCopyBufferToImage2( static_cast<VkCommandBuffer>( m_commandBuffer ),
14642  reinterpret_cast<const VkCopyBufferToImageInfo2 *>( &copyBufferToImageInfo ) );
14643  }
14644 
14645  VULKAN_HPP_INLINE void
14646  CommandBuffer::copyImageToBuffer2( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT
14647  {
14648  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyImageToBuffer2 &&
14649  "Function <vkCmdCopyImageToBuffer2> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" );
14650 
14651  getDispatcher()->vkCmdCopyImageToBuffer2( static_cast<VkCommandBuffer>( m_commandBuffer ),
14652  reinterpret_cast<const VkCopyImageToBufferInfo2 *>( &copyImageToBufferInfo ) );
14653  }
14654 
14655  VULKAN_HPP_INLINE void CommandBuffer::blitImage2( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo ) const VULKAN_HPP_NOEXCEPT
14656  {
14657  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBlitImage2 && "Function <vkCmdBlitImage2> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" );
14658 
14659  getDispatcher()->vkCmdBlitImage2( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkBlitImageInfo2 *>( &blitImageInfo ) );
14660  }
14661 
14662  VULKAN_HPP_INLINE void CommandBuffer::resolveImage2( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo ) const VULKAN_HPP_NOEXCEPT
14663  {
14664  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdResolveImage2 && "Function <vkCmdResolveImage2> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" );
14665 
14666  getDispatcher()->vkCmdResolveImage2( static_cast<VkCommandBuffer>( m_commandBuffer ),
14667  reinterpret_cast<const VkResolveImageInfo2 *>( &resolveImageInfo ) );
14668  }
14669 
14670  VULKAN_HPP_INLINE void CommandBuffer::beginRendering( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo ) const VULKAN_HPP_NOEXCEPT
14671  {
14672  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginRendering && "Function <vkCmdBeginRendering> requires <VK_KHR_dynamic_rendering> or <VK_VERSION_1_3>" );
14673 
14674  getDispatcher()->vkCmdBeginRendering( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkRenderingInfo *>( &renderingInfo ) );
14675  }
14676 
14677  VULKAN_HPP_INLINE void CommandBuffer::endRendering() const VULKAN_HPP_NOEXCEPT
14678  {
14679  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndRendering && "Function <vkCmdEndRendering> requires <VK_KHR_dynamic_rendering> or <VK_VERSION_1_3>" );
14680 
14681  getDispatcher()->vkCmdEndRendering( static_cast<VkCommandBuffer>( m_commandBuffer ) );
14682  }
14683 
14684  VULKAN_HPP_INLINE void CommandBuffer::setCullMode( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT
14685  {
14686  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCullMode &&
14687  "Function <vkCmdSetCullMode> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
14688 
14689  getDispatcher()->vkCmdSetCullMode( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkCullModeFlags>( cullMode ) );
14690  }
14691 
14692  VULKAN_HPP_INLINE void CommandBuffer::setFrontFace( VULKAN_HPP_NAMESPACE::FrontFace frontFace ) const VULKAN_HPP_NOEXCEPT
14693  {
14694  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetFrontFace &&
14695  "Function <vkCmdSetFrontFace> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
14696 
14697  getDispatcher()->vkCmdSetFrontFace( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkFrontFace>( frontFace ) );
14698  }
14699 
14700  VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveTopology( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT
14701  {
14702  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetPrimitiveTopology &&
14703  "Function <vkCmdSetPrimitiveTopology> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
14704 
14705  getDispatcher()->vkCmdSetPrimitiveTopology( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPrimitiveTopology>( primitiveTopology ) );
14706  }
14707 
14708  VULKAN_HPP_INLINE void
14709  CommandBuffer::setViewportWithCount( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports ) const VULKAN_HPP_NOEXCEPT
14710  {
14711  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetViewportWithCount &&
14712  "Function <vkCmdSetViewportWithCount> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
14713 
14714  getDispatcher()->vkCmdSetViewportWithCount(
14715  static_cast<VkCommandBuffer>( m_commandBuffer ), viewports.size(), reinterpret_cast<const VkViewport *>( viewports.data() ) );
14716  }
14717 
14718  VULKAN_HPP_INLINE void
14719  CommandBuffer::setScissorWithCount( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors ) const VULKAN_HPP_NOEXCEPT
14720  {
14721  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetScissorWithCount &&
14722  "Function <vkCmdSetScissorWithCount> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
14723 
14724  getDispatcher()->vkCmdSetScissorWithCount(
14725  static_cast<VkCommandBuffer>( m_commandBuffer ), scissors.size(), reinterpret_cast<const VkRect2D *>( scissors.data() ) );
14726  }
14727 
14728  VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers2( uint32_t firstBinding,
14729  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers,
14730  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
14731  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes,
14732  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides ) const
14733  {
14734  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindVertexBuffers2 &&
14735  "Function <vkCmdBindVertexBuffers2> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
14736 # ifdef VULKAN_HPP_NO_EXCEPTIONS
14737  VULKAN_HPP_ASSERT( buffers.size() == offsets.size() );
14738  VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() );
14739  VULKAN_HPP_ASSERT( strides.empty() || buffers.size() == strides.size() );
14740 # else
14741  if ( buffers.size() != offsets.size() )
14742  {
14743  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2: buffers.size() != offsets.size()" );
14744  }
14745  if ( !sizes.empty() && buffers.size() != sizes.size() )
14746  {
14747  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2: buffers.size() != sizes.size()" );
14748  }
14749  if ( !strides.empty() && buffers.size() != strides.size() )
14750  {
14751  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2: buffers.size() != strides.size()" );
14752  }
14753 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
14754 
14755  getDispatcher()->vkCmdBindVertexBuffers2( static_cast<VkCommandBuffer>( m_commandBuffer ),
14756  firstBinding,
14757  buffers.size(),
14758  reinterpret_cast<const VkBuffer *>( buffers.data() ),
14759  reinterpret_cast<const VkDeviceSize *>( offsets.data() ),
14760  reinterpret_cast<const VkDeviceSize *>( sizes.data() ),
14761  reinterpret_cast<const VkDeviceSize *>( strides.data() ) );
14762  }
14763 
14764  VULKAN_HPP_INLINE void CommandBuffer::setDepthTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT
14765  {
14766  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthTestEnable &&
14767  "Function <vkCmdSetDepthTestEnable> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
14768 
14769  getDispatcher()->vkCmdSetDepthTestEnable( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthTestEnable ) );
14770  }
14771 
14772  VULKAN_HPP_INLINE void CommandBuffer::setDepthWriteEnable( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT
14773  {
14774  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthWriteEnable &&
14775  "Function <vkCmdSetDepthWriteEnable> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
14776 
14777  getDispatcher()->vkCmdSetDepthWriteEnable( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthWriteEnable ) );
14778  }
14779 
14780  VULKAN_HPP_INLINE void CommandBuffer::setDepthCompareOp( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT
14781  {
14782  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthCompareOp &&
14783  "Function <vkCmdSetDepthCompareOp> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
14784 
14785  getDispatcher()->vkCmdSetDepthCompareOp( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkCompareOp>( depthCompareOp ) );
14786  }
14787 
14788  VULKAN_HPP_INLINE void CommandBuffer::setDepthBoundsTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT
14789  {
14791  "Function <vkCmdSetDepthBoundsTestEnable> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
14792 
14793  getDispatcher()->vkCmdSetDepthBoundsTestEnable( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthBoundsTestEnable ) );
14794  }
14795 
14796  VULKAN_HPP_INLINE void CommandBuffer::setStencilTestEnable( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT
14797  {
14798  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilTestEnable &&
14799  "Function <vkCmdSetStencilTestEnable> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
14800 
14801  getDispatcher()->vkCmdSetStencilTestEnable( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( stencilTestEnable ) );
14802  }
14803 
14804  VULKAN_HPP_INLINE void CommandBuffer::setStencilOp( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
14807  VULKAN_HPP_NAMESPACE::StencilOp depthFailOp,
14809  {
14810  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilOp &&
14811  "Function <vkCmdSetStencilOp> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
14812 
14813  getDispatcher()->vkCmdSetStencilOp( static_cast<VkCommandBuffer>( m_commandBuffer ),
14814  static_cast<VkStencilFaceFlags>( faceMask ),
14815  static_cast<VkStencilOp>( failOp ),
14816  static_cast<VkStencilOp>( passOp ),
14817  static_cast<VkStencilOp>( depthFailOp ),
14818  static_cast<VkCompareOp>( compareOp ) );
14819  }
14820 
14821  VULKAN_HPP_INLINE void CommandBuffer::setRasterizerDiscardEnable( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT
14822  {
14824  "Function <vkCmdSetRasterizerDiscardEnable> requires <VK_EXT_extended_dynamic_state2> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
14825 
14826  getDispatcher()->vkCmdSetRasterizerDiscardEnable( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( rasterizerDiscardEnable ) );
14827  }
14828 
14829  VULKAN_HPP_INLINE void CommandBuffer::setDepthBiasEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT
14830  {
14831  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthBiasEnable &&
14832  "Function <vkCmdSetDepthBiasEnable> requires <VK_EXT_extended_dynamic_state2> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
14833 
14834  getDispatcher()->vkCmdSetDepthBiasEnable( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthBiasEnable ) );
14835  }
14836 
14837  VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveRestartEnable( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT
14838  {
14840  "Function <vkCmdSetPrimitiveRestartEnable> requires <VK_EXT_extended_dynamic_state2> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
14841 
14842  getDispatcher()->vkCmdSetPrimitiveRestartEnable( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( primitiveRestartEnable ) );
14843  }
14844 
14845  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2
14846  Device::getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT
14847  {
14849  "Function <vkGetDeviceBufferMemoryRequirements> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" );
14850 
14851  VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
14852  getDispatcher()->vkGetDeviceBufferMemoryRequirements( static_cast<VkDevice>( m_device ),
14853  reinterpret_cast<const VkDeviceBufferMemoryRequirements *>( &info ),
14854  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
14855 
14856  return memoryRequirements;
14857  }
14858 
14859  template <typename X, typename Y, typename... Z>
14860  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
14861  Device::getBufferMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT
14862  {
14864  "Function <vkGetDeviceBufferMemoryRequirements> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" );
14865 
14866  VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
14867  VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
14868  getDispatcher()->vkGetDeviceBufferMemoryRequirements( static_cast<VkDevice>( m_device ),
14869  reinterpret_cast<const VkDeviceBufferMemoryRequirements *>( &info ),
14870  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
14871 
14872  return structureChain;
14873  }
14874 
14875  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2
14876  Device::getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT
14877  {
14879  "Function <vkGetDeviceImageMemoryRequirements> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" );
14880 
14881  VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
14882  getDispatcher()->vkGetDeviceImageMemoryRequirements( static_cast<VkDevice>( m_device ),
14883  reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ),
14884  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
14885 
14886  return memoryRequirements;
14887  }
14888 
14889  template <typename X, typename Y, typename... Z>
14890  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
14891  Device::getImageMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT
14892  {
14894  "Function <vkGetDeviceImageMemoryRequirements> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" );
14895 
14896  VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
14897  VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
14898  getDispatcher()->vkGetDeviceImageMemoryRequirements( static_cast<VkDevice>( m_device ),
14899  reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ),
14900  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
14901 
14902  return structureChain;
14903  }
14904 
14905  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>
14906  Device::getImageSparseMemoryRequirements( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const
14907  {
14909  "Function <vkGetDeviceImageSparseMemoryRequirements> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" );
14910 
14911  std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> sparseMemoryRequirements;
14912  uint32_t sparseMemoryRequirementCount;
14913  getDispatcher()->vkGetDeviceImageSparseMemoryRequirements(
14914  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), &sparseMemoryRequirementCount, nullptr );
14915  sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
14916  getDispatcher()->vkGetDeviceImageSparseMemoryRequirements( static_cast<VkDevice>( m_device ),
14917  reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ),
14918  &sparseMemoryRequirementCount,
14919  reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
14920 
14921  VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
14922  if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() )
14923  {
14924  sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
14925  }
14926  return sparseMemoryRequirements;
14927  }
14928 
14929  //=== VK_KHR_surface ===
14930 
14931  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex,
14932  VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const
14933  {
14934  VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfaceSupportKHR && "Function <vkGetPhysicalDeviceSurfaceSupportKHR> requires <VK_KHR_surface>" );
14935 
14936  VULKAN_HPP_NAMESPACE::Bool32 supported;
14938  static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceSurfaceSupportKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14939  queueFamilyIndex,
14940  static_cast<VkSurfaceKHR>( surface ),
14941  reinterpret_cast<VkBool32 *>( &supported ) ) );
14942  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceSupportKHR" );
14943 
14944  return supported;
14945  }
14946 
14947  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR
14948  PhysicalDevice::getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const
14949  {
14951  "Function <vkGetPhysicalDeviceSurfaceCapabilitiesKHR> requires <VK_KHR_surface>" );
14952 
14953  VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR surfaceCapabilities;
14955  getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilitiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14956  static_cast<VkSurfaceKHR>( surface ),
14957  reinterpret_cast<VkSurfaceCapabilitiesKHR *>( &surfaceCapabilities ) ) );
14958  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilitiesKHR" );
14959 
14960  return surfaceCapabilities;
14961  }
14962 
14963  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>
14964  PhysicalDevice::getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const
14965  {
14966  VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfaceFormatsKHR && "Function <vkGetPhysicalDeviceSurfaceFormatsKHR> requires <VK_KHR_surface>" );
14967 
14968  std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR> surfaceFormats;
14969  uint32_t surfaceFormatCount;
14971  do
14972  {
14973  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceSurfaceFormatsKHR(
14974  static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, nullptr ) );
14975  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && surfaceFormatCount )
14976  {
14977  surfaceFormats.resize( surfaceFormatCount );
14978  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
14979  getDispatcher()->vkGetPhysicalDeviceSurfaceFormatsKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
14980  static_cast<VkSurfaceKHR>( surface ),
14981  &surfaceFormatCount,
14982  reinterpret_cast<VkSurfaceFormatKHR *>( surfaceFormats.data() ) ) );
14983  }
14984  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
14985  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormatsKHR" );
14986  VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
14987  if ( surfaceFormatCount < surfaceFormats.size() )
14988  {
14989  surfaceFormats.resize( surfaceFormatCount );
14990  }
14991  return surfaceFormats;
14992  }
14993 
14994  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR>
14995  PhysicalDevice::getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const
14996  {
14998  "Function <vkGetPhysicalDeviceSurfacePresentModesKHR> requires <VK_KHR_surface>" );
14999 
15000  std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR> presentModes;
15001  uint32_t presentModeCount;
15003  do
15004  {
15005  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceSurfacePresentModesKHR(
15006  static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkSurfaceKHR>( surface ), &presentModeCount, nullptr ) );
15007  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && presentModeCount )
15008  {
15009  presentModes.resize( presentModeCount );
15010  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
15011  getDispatcher()->vkGetPhysicalDeviceSurfacePresentModesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
15012  static_cast<VkSurfaceKHR>( surface ),
15013  &presentModeCount,
15014  reinterpret_cast<VkPresentModeKHR *>( presentModes.data() ) ) );
15015  }
15016  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
15017  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModesKHR" );
15018  VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() );
15019  if ( presentModeCount < presentModes.size() )
15020  {
15021  presentModes.resize( presentModeCount );
15022  }
15023  return presentModes;
15024  }
15025 
15026  //=== VK_KHR_swapchain ===
15027 
15029  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR>::Type
15030  Device::createSwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & createInfo,
15031  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
15033  {
15034  VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain;
15035  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateSwapchainKHR(
15036  static_cast<VkDevice>( m_device ),
15037  reinterpret_cast<const VkSwapchainCreateInfoKHR *>( &createInfo ),
15038  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
15039  reinterpret_cast<VkSwapchainKHR *>( &swapchain ) ) );
15040  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
15041  {
15042 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
15043  return VULKAN_HPP_UNEXPECTED( result );
15044 # else
15045  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createSwapchainKHR" );
15046 # endif
15047  }
15048 
15049  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR( *this, *reinterpret_cast<VkSwapchainKHR *>( &swapchain ), allocator );
15050  }
15051 
15052  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::Image> SwapchainKHR::getImages() const
15053  {
15054  VULKAN_HPP_ASSERT( getDispatcher()->vkGetSwapchainImagesKHR && "Function <vkGetSwapchainImagesKHR> requires <VK_KHR_swapchain>" );
15055 
15056  std::vector<VULKAN_HPP_NAMESPACE::Image> swapchainImages;
15057  uint32_t swapchainImageCount;
15059  do
15060  {
15061  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetSwapchainImagesKHR(
15062  static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), &swapchainImageCount, nullptr ) );
15063  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && swapchainImageCount )
15064  {
15065  swapchainImages.resize( swapchainImageCount );
15066  result =
15067  static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetSwapchainImagesKHR( static_cast<VkDevice>( m_device ),
15068  static_cast<VkSwapchainKHR>( m_swapchain ),
15069  &swapchainImageCount,
15070  reinterpret_cast<VkImage *>( swapchainImages.data() ) ) );
15071  }
15072  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
15073  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getImages" );
15074  VULKAN_HPP_ASSERT( swapchainImageCount <= swapchainImages.size() );
15075  if ( swapchainImageCount < swapchainImages.size() )
15076  {
15077  swapchainImages.resize( swapchainImageCount );
15078  }
15079  return swapchainImages;
15080  }
15081 
15082  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, uint32_t>
15083  SwapchainKHR::acquireNextImage( uint64_t timeout, VULKAN_HPP_NAMESPACE::Semaphore semaphore, VULKAN_HPP_NAMESPACE::Fence fence ) const
15084  {
15085  VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireNextImageKHR && "Function <vkAcquireNextImageKHR> requires <VK_KHR_swapchain>" );
15086 
15087  uint32_t imageIndex;
15089  static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkAcquireNextImageKHR( static_cast<VkDevice>( m_device ),
15090  static_cast<VkSwapchainKHR>( m_swapchain ),
15091  timeout,
15092  static_cast<VkSemaphore>( semaphore ),
15093  static_cast<VkFence>( fence ),
15094  &imageIndex ) );
15095  resultCheck( result,
15096  VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::acquireNextImage",
15097  { VULKAN_HPP_NAMESPACE::Result::eSuccess,
15098  VULKAN_HPP_NAMESPACE::Result::eTimeout,
15099  VULKAN_HPP_NAMESPACE::Result::eNotReady,
15100  VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } );
15101 
15102  return std::make_pair( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), imageIndex );
15103  }
15104 
15105  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Queue::presentKHR( const VULKAN_HPP_NAMESPACE::PresentInfoKHR & presentInfo ) const
15106  {
15107  VULKAN_HPP_ASSERT( getDispatcher()->vkQueuePresentKHR && "Function <vkQueuePresentKHR> requires <VK_KHR_swapchain>" );
15108 
15110  getDispatcher()->vkQueuePresentKHR( static_cast<VkQueue>( m_queue ), reinterpret_cast<const VkPresentInfoKHR *>( &presentInfo ) ) );
15111  resultCheck(
15112  result, VULKAN_HPP_NAMESPACE_STRING "::Queue::presentKHR", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } );
15113 
15114  return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
15115  }
15116 
15117  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR Device::getGroupPresentCapabilitiesKHR() const
15118  {
15120  "Function <vkGetDeviceGroupPresentCapabilitiesKHR> requires <VK_KHR_device_group> or <VK_KHR_swapchain>" );
15121 
15122  VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR deviceGroupPresentCapabilities;
15123  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDeviceGroupPresentCapabilitiesKHR(
15124  static_cast<VkDevice>( m_device ), reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR *>( &deviceGroupPresentCapabilities ) ) );
15125  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupPresentCapabilitiesKHR" );
15126 
15127  return deviceGroupPresentCapabilities;
15128  }
15129 
15131  Device::getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const
15132  {
15134  "Function <vkGetDeviceGroupSurfacePresentModesKHR> requires <VK_KHR_device_group> or <VK_KHR_swapchain>" );
15135 
15137  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDeviceGroupSurfacePresentModesKHR(
15138  static_cast<VkDevice>( m_device ), static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( &modes ) ) );
15139  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModesKHR" );
15140 
15141  return modes;
15142  }
15143 
15144  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::Rect2D>
15145  PhysicalDevice::getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const
15146  {
15148  "Function <vkGetPhysicalDevicePresentRectanglesKHR> requires <VK_KHR_device_group> or <VK_KHR_swapchain>" );
15149 
15150  std::vector<VULKAN_HPP_NAMESPACE::Rect2D> rects;
15151  uint32_t rectCount;
15153  do
15154  {
15155  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDevicePresentRectanglesKHR(
15156  static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkSurfaceKHR>( surface ), &rectCount, nullptr ) );
15157  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && rectCount )
15158  {
15159  rects.resize( rectCount );
15160  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
15161  getDispatcher()->vkGetPhysicalDevicePresentRectanglesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
15162  static_cast<VkSurfaceKHR>( surface ),
15163  &rectCount,
15164  reinterpret_cast<VkRect2D *>( rects.data() ) ) );
15165  }
15166  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
15167  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getPresentRectanglesKHR" );
15168  VULKAN_HPP_ASSERT( rectCount <= rects.size() );
15169  if ( rectCount < rects.size() )
15170  {
15171  rects.resize( rectCount );
15172  }
15173  return rects;
15174  }
15175 
15176  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, uint32_t>
15177  Device::acquireNextImage2KHR( const VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR & acquireInfo ) const
15178  {
15179  VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireNextImage2KHR && "Function <vkAcquireNextImage2KHR> requires <VK_KHR_device_group> or <VK_KHR_swapchain>" );
15180 
15181  uint32_t imageIndex;
15182  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkAcquireNextImage2KHR(
15183  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkAcquireNextImageInfoKHR *>( &acquireInfo ), &imageIndex ) );
15184  resultCheck( result,
15185  VULKAN_HPP_NAMESPACE_STRING "::Device::acquireNextImage2KHR",
15186  { VULKAN_HPP_NAMESPACE::Result::eSuccess,
15187  VULKAN_HPP_NAMESPACE::Result::eTimeout,
15188  VULKAN_HPP_NAMESPACE::Result::eNotReady,
15189  VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } );
15190 
15191  return std::make_pair( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), imageIndex );
15192  }
15193 
15194  //=== VK_KHR_display ===
15195 
15196  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR> PhysicalDevice::getDisplayPropertiesKHR() const
15197  {
15199  "Function <vkGetPhysicalDeviceDisplayPropertiesKHR> requires <VK_KHR_display>" );
15200 
15201  std::vector<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR> properties;
15202  uint32_t propertyCount;
15204  do
15205  {
15206  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
15207  getDispatcher()->vkGetPhysicalDeviceDisplayPropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, nullptr ) );
15208  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount )
15209  {
15210  properties.resize( propertyCount );
15211  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceDisplayPropertiesKHR(
15212  static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, reinterpret_cast<VkDisplayPropertiesKHR *>( properties.data() ) ) );
15213  }
15214  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
15215  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPropertiesKHR" );
15216  VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
15217  if ( propertyCount < properties.size() )
15218  {
15219  properties.resize( propertyCount );
15220  }
15221  return properties;
15222  }
15223 
15224  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR> PhysicalDevice::getDisplayPlanePropertiesKHR() const
15225  {
15227  "Function <vkGetPhysicalDeviceDisplayPlanePropertiesKHR> requires <VK_KHR_display>" );
15228 
15229  std::vector<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR> properties;
15230  uint32_t propertyCount;
15232  do
15233  {
15234  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
15235  getDispatcher()->vkGetPhysicalDeviceDisplayPlanePropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, nullptr ) );
15236  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount )
15237  {
15238  properties.resize( propertyCount );
15239  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
15240  static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR *>( properties.data() ) ) );
15241  }
15242  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
15243  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlanePropertiesKHR" );
15244  VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
15245  if ( propertyCount < properties.size() )
15246  {
15247  properties.resize( propertyCount );
15248  }
15249  return properties;
15250  }
15251 
15253  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR>>::Type
15254  PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex ) const
15255  {
15256  std::vector<VULKAN_HPP_NAMESPACE::DisplayKHR> displays;
15257  uint32_t displayCount;
15259  do
15260  {
15261  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
15262  getDispatcher()->vkGetDisplayPlaneSupportedDisplaysKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), planeIndex, &displayCount, nullptr ) );
15263  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && displayCount )
15264  {
15265  displays.resize( displayCount );
15266  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDisplayPlaneSupportedDisplaysKHR(
15267  static_cast<VkPhysicalDevice>( m_physicalDevice ), planeIndex, &displayCount, reinterpret_cast<VkDisplayKHR *>( displays.data() ) ) );
15268  }
15269  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
15270  if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( result != VULKAN_HPP_NAMESPACE::Result::eIncomplete ) )
15271  {
15272 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
15273  return VULKAN_HPP_UNEXPECTED( result );
15274 # else
15275  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR" );
15276 # endif
15277  }
15278 
15279  std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR> displaysRAII;
15280  displaysRAII.reserve( displays.size() );
15281  for ( auto & display : displays )
15282  {
15283  displaysRAII.emplace_back( *this, *reinterpret_cast<VkDisplayKHR *>( &display ) );
15284  }
15285  return displaysRAII;
15286  }
15287 
15288  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR> DisplayKHR::getModeProperties() const
15289  {
15290  VULKAN_HPP_ASSERT( getDispatcher()->vkGetDisplayModePropertiesKHR && "Function <vkGetDisplayModePropertiesKHR> requires <VK_KHR_display>" );
15291 
15292  std::vector<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR> properties;
15293  uint32_t propertyCount;
15295  do
15296  {
15297  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDisplayModePropertiesKHR(
15298  static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkDisplayKHR>( m_display ), &propertyCount, nullptr ) );
15299  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount )
15300  {
15301  properties.resize( propertyCount );
15302  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
15303  getDispatcher()->vkGetDisplayModePropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
15304  static_cast<VkDisplayKHR>( m_display ),
15305  &propertyCount,
15306  reinterpret_cast<VkDisplayModePropertiesKHR *>( properties.data() ) ) );
15307  }
15308  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
15309  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::DisplayKHR::getModeProperties" );
15310  VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
15311  if ( propertyCount < properties.size() )
15312  {
15313  properties.resize( propertyCount );
15314  }
15315  return properties;
15316  }
15317 
15319  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayModeKHR>::Type
15320  DisplayKHR::createMode( VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR const & createInfo,
15321  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT
15322  {
15323  VULKAN_HPP_NAMESPACE::DisplayModeKHR mode;
15324  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateDisplayModeKHR(
15325  static_cast<VkPhysicalDevice>( m_physicalDevice ),
15326  static_cast<VkDisplayKHR>( m_display ),
15327  reinterpret_cast<const VkDisplayModeCreateInfoKHR *>( &createInfo ),
15328  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
15329  reinterpret_cast<VkDisplayModeKHR *>( &mode ) ) );
15330  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
15331  {
15332 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
15333  return VULKAN_HPP_UNEXPECTED( result );
15334 # else
15335  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "DisplayKHR::createMode" );
15336 # endif
15337  }
15338 
15339  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayModeKHR( *this, *reinterpret_cast<VkDisplayModeKHR *>( &mode ) );
15340  }
15341 
15342  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR
15343  DisplayModeKHR::getDisplayPlaneCapabilities( uint32_t planeIndex ) const
15344  {
15345  VULKAN_HPP_ASSERT( getDispatcher()->vkGetDisplayPlaneCapabilitiesKHR && "Function <vkGetDisplayPlaneCapabilitiesKHR> requires <VK_KHR_display>" );
15346 
15347  VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR capabilities;
15349  getDispatcher()->vkGetDisplayPlaneCapabilitiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
15350  static_cast<VkDisplayModeKHR>( m_displayModeKHR ),
15351  planeIndex,
15352  reinterpret_cast<VkDisplayPlaneCapabilitiesKHR *>( &capabilities ) ) );
15353  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::DisplayModeKHR::getDisplayPlaneCapabilities" );
15354 
15355  return capabilities;
15356  }
15357 
15359  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type
15360  Instance::createDisplayPlaneSurfaceKHR( VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR const & createInfo,
15361  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
15363  {
15364  VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
15365  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateDisplayPlaneSurfaceKHR(
15366  static_cast<VkInstance>( m_instance ),
15367  reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR *>( &createInfo ),
15368  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
15369  reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
15370  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
15371  {
15372 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
15373  return VULKAN_HPP_UNEXPECTED( result );
15374 # else
15375  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Instance::createDisplayPlaneSurfaceKHR" );
15376 # endif
15377  }
15378 
15379  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, *reinterpret_cast<VkSurfaceKHR *>( &surface ), allocator );
15380  }
15381 
15382  //=== VK_KHR_display_swapchain ===
15383 
15385  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR>>::Type
15386  Device::createSharedSwapchainsKHR( VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR> const & createInfos,
15387  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
15388  {
15389  std::vector<VULKAN_HPP_NAMESPACE::SwapchainKHR> swapchains( createInfos.size() );
15390  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateSharedSwapchainsKHR(
15391  static_cast<VkDevice>( m_device ),
15392  createInfos.size(),
15393  reinterpret_cast<const VkSwapchainCreateInfoKHR *>( createInfos.data() ),
15394  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
15395  reinterpret_cast<VkSwapchainKHR *>( swapchains.data() ) ) );
15396  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
15397  {
15398 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
15399  return VULKAN_HPP_UNEXPECTED( result );
15400 # else
15401  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createSharedSwapchainsKHR" );
15402 # endif
15403  }
15404 
15405  std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR> swapchainsRAII;
15406  swapchainsRAII.reserve( swapchains.size() );
15407  for ( auto & swapchain : swapchains )
15408  {
15409  swapchainsRAII.emplace_back( *this, *reinterpret_cast<VkSwapchainKHR *>( &swapchain ), allocator );
15410  }
15411  return swapchainsRAII;
15412  }
15413 
15415  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR>::Type
15416  Device::createSharedSwapchainKHR( VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & createInfo,
15417  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
15419  {
15420  VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain;
15421  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateSharedSwapchainsKHR(
15422  static_cast<VkDevice>( m_device ),
15423  1,
15424  reinterpret_cast<const VkSwapchainCreateInfoKHR *>( &createInfo ),
15425  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
15426  reinterpret_cast<VkSwapchainKHR *>( &swapchain ) ) );
15427  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
15428  {
15429 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
15430  return VULKAN_HPP_UNEXPECTED( result );
15431 # else
15432  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createSharedSwapchainKHR" );
15433 # endif
15434  }
15435 
15436  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR( *this, *reinterpret_cast<VkSwapchainKHR *>( &swapchain ), allocator );
15437  }
15438 
15439 # if defined( VK_USE_PLATFORM_XLIB_KHR )
15440  //=== VK_KHR_xlib_surface ===
15441 
15443  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type
15444  Instance::createXlibSurfaceKHR( VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR const & createInfo,
15445  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
15447  {
15448  VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
15449  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateXlibSurfaceKHR(
15450  static_cast<VkInstance>( m_instance ),
15451  reinterpret_cast<const VkXlibSurfaceCreateInfoKHR *>( &createInfo ),
15452  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
15453  reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
15454  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
15455  {
15456 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
15457  return VULKAN_HPP_UNEXPECTED( result );
15458 # else
15459  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Instance::createXlibSurfaceKHR" );
15460 # endif
15461  }
15462 
15463  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, *reinterpret_cast<VkSurfaceKHR *>( &surface ), allocator );
15464  }
15465 
15467  PhysicalDevice::getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID ) const VULKAN_HPP_NOEXCEPT
15468  {
15469  VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceXlibPresentationSupportKHR &&
15470  "Function <vkGetPhysicalDeviceXlibPresentationSupportKHR> requires <VK_KHR_xlib_surface>" );
15471 
15472  VkBool32 result =
15473  getDispatcher()->vkGetPhysicalDeviceXlibPresentationSupportKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &dpy, visualID );
15474 
15475  return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( result );
15476  }
15477 # endif /*VK_USE_PLATFORM_XLIB_KHR*/
15478 
15479 # if defined( VK_USE_PLATFORM_XCB_KHR )
15480  //=== VK_KHR_xcb_surface ===
15481 
15483  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type
15484  Instance::createXcbSurfaceKHR( VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR const & createInfo,
15485  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
15487  {
15488  VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
15489  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateXcbSurfaceKHR(
15490  static_cast<VkInstance>( m_instance ),
15491  reinterpret_cast<const VkXcbSurfaceCreateInfoKHR *>( &createInfo ),
15492  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
15493  reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
15494  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
15495  {
15496 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
15497  return VULKAN_HPP_UNEXPECTED( result );
15498 # else
15499  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Instance::createXcbSurfaceKHR" );
15500 # endif
15501  }
15502 
15503  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, *reinterpret_cast<VkSurfaceKHR *>( &surface ), allocator );
15504  }
15505 
15506  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Bool32 PhysicalDevice::getXcbPresentationSupportKHR(
15507  uint32_t queueFamilyIndex, xcb_connection_t & connection, xcb_visualid_t visual_id ) const VULKAN_HPP_NOEXCEPT
15508  {
15509  VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceXcbPresentationSupportKHR &&
15510  "Function <vkGetPhysicalDeviceXcbPresentationSupportKHR> requires <VK_KHR_xcb_surface>" );
15511 
15512  VkBool32 result = getDispatcher()->vkGetPhysicalDeviceXcbPresentationSupportKHR(
15513  static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &connection, visual_id );
15514 
15515  return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( result );
15516  }
15517 # endif /*VK_USE_PLATFORM_XCB_KHR*/
15518 
15519 # if defined( VK_USE_PLATFORM_WAYLAND_KHR )
15520  //=== VK_KHR_wayland_surface ===
15521 
15523  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type
15524  Instance::createWaylandSurfaceKHR( VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR const & createInfo,
15525  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
15527  {
15528  VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
15529  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateWaylandSurfaceKHR(
15530  static_cast<VkInstance>( m_instance ),
15531  reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR *>( &createInfo ),
15532  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
15533  reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
15534  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
15535  {
15536 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
15537  return VULKAN_HPP_UNEXPECTED( result );
15538 # else
15539  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Instance::createWaylandSurfaceKHR" );
15540 # endif
15541  }
15542 
15543  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, *reinterpret_cast<VkSurfaceKHR *>( &surface ), allocator );
15544  }
15545 
15547  PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display & display ) const VULKAN_HPP_NOEXCEPT
15548  {
15549  VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceWaylandPresentationSupportKHR &&
15550  "Function <vkGetPhysicalDeviceWaylandPresentationSupportKHR> requires <VK_KHR_wayland_surface>" );
15551 
15552  VkBool32 result =
15553  getDispatcher()->vkGetPhysicalDeviceWaylandPresentationSupportKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &display );
15554 
15555  return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( result );
15556  }
15557 # endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
15558 
15559 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
15560  //=== VK_KHR_android_surface ===
15561 
15563  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type
15564  Instance::createAndroidSurfaceKHR( VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR const & createInfo,
15565  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
15567  {
15568  VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
15569  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateAndroidSurfaceKHR(
15570  static_cast<VkInstance>( m_instance ),
15571  reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR *>( &createInfo ),
15572  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
15573  reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
15574  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
15575  {
15576 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
15577  return VULKAN_HPP_UNEXPECTED( result );
15578 # else
15579  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Instance::createAndroidSurfaceKHR" );
15580 # endif
15581  }
15582 
15583  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, *reinterpret_cast<VkSurfaceKHR *>( &surface ), allocator );
15584  }
15585 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
15586 
15587 # if defined( VK_USE_PLATFORM_WIN32_KHR )
15588  //=== VK_KHR_win32_surface ===
15589 
15591  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type
15592  Instance::createWin32SurfaceKHR( VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR const & createInfo,
15593  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
15595  {
15596  VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
15597  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateWin32SurfaceKHR(
15598  static_cast<VkInstance>( m_instance ),
15599  reinterpret_cast<const VkWin32SurfaceCreateInfoKHR *>( &createInfo ),
15600  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
15601  reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
15602  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
15603  {
15604 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
15605  return VULKAN_HPP_UNEXPECTED( result );
15606 # else
15607  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Instance::createWin32SurfaceKHR" );
15608 # endif
15609  }
15610 
15611  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, *reinterpret_cast<VkSurfaceKHR *>( &surface ), allocator );
15612  }
15613 
15615  PhysicalDevice::getWin32PresentationSupportKHR( uint32_t queueFamilyIndex ) const VULKAN_HPP_NOEXCEPT
15616  {
15617  VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceWin32PresentationSupportKHR &&
15618  "Function <vkGetPhysicalDeviceWin32PresentationSupportKHR> requires <VK_KHR_win32_surface>" );
15619 
15620  VkBool32 result = getDispatcher()->vkGetPhysicalDeviceWin32PresentationSupportKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex );
15621 
15622  return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( result );
15623  }
15624 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
15625 
15626  //=== VK_EXT_debug_report ===
15627 
15629  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DebugReportCallbackEXT>::Type
15630  Instance::createDebugReportCallbackEXT( VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT const & createInfo,
15631  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
15633  {
15634  VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback;
15635  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateDebugReportCallbackEXT(
15636  static_cast<VkInstance>( m_instance ),
15637  reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>( &createInfo ),
15638  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
15639  reinterpret_cast<VkDebugReportCallbackEXT *>( &callback ) ) );
15640  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
15641  {
15642 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
15643  return VULKAN_HPP_UNEXPECTED( result );
15644 # else
15645  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Instance::createDebugReportCallbackEXT" );
15646 # endif
15647  }
15648 
15649  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DebugReportCallbackEXT(
15650  *this, *reinterpret_cast<VkDebugReportCallbackEXT *>( &callback ), allocator );
15651  }
15652 
15653  VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT flags,
15655  uint64_t object,
15656  size_t location,
15657  int32_t messageCode,
15658  const std::string & layerPrefix,
15659  const std::string & message ) const VULKAN_HPP_NOEXCEPT
15660  {
15661  VULKAN_HPP_ASSERT( getDispatcher()->vkDebugReportMessageEXT && "Function <vkDebugReportMessageEXT> requires <VK_EXT_debug_report>" );
15662 
15663  getDispatcher()->vkDebugReportMessageEXT( static_cast<VkInstance>( m_instance ),
15664  static_cast<VkDebugReportFlagsEXT>( flags ),
15665  static_cast<VkDebugReportObjectTypeEXT>( objectType_ ),
15666  object,
15667  location,
15668  messageCode,
15669  layerPrefix.c_str(),
15670  message.c_str() );
15671  }
15672 
15673  //=== VK_EXT_debug_marker ===
15674 
15675  VULKAN_HPP_INLINE void Device::debugMarkerSetObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT & tagInfo ) const
15676  {
15677  VULKAN_HPP_ASSERT( getDispatcher()->vkDebugMarkerSetObjectTagEXT && "Function <vkDebugMarkerSetObjectTagEXT> requires <VK_EXT_debug_marker>" );
15678 
15679  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkDebugMarkerSetObjectTagEXT(
15680  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT *>( &tagInfo ) ) );
15681  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::debugMarkerSetObjectTagEXT" );
15682  }
15683 
15684  VULKAN_HPP_INLINE void Device::debugMarkerSetObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT & nameInfo ) const
15685  {
15686  VULKAN_HPP_ASSERT( getDispatcher()->vkDebugMarkerSetObjectNameEXT && "Function <vkDebugMarkerSetObjectNameEXT> requires <VK_EXT_debug_marker>" );
15687 
15688  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkDebugMarkerSetObjectNameEXT(
15689  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT *>( &nameInfo ) ) );
15690  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::debugMarkerSetObjectNameEXT" );
15691  }
15692 
15693  VULKAN_HPP_INLINE void CommandBuffer::debugMarkerBeginEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo ) const VULKAN_HPP_NOEXCEPT
15694  {
15695  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDebugMarkerBeginEXT && "Function <vkCmdDebugMarkerBeginEXT> requires <VK_EXT_debug_marker>" );
15696 
15697  getDispatcher()->vkCmdDebugMarkerBeginEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
15698  reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( &markerInfo ) );
15699  }
15700 
15701  VULKAN_HPP_INLINE void CommandBuffer::debugMarkerEndEXT() const VULKAN_HPP_NOEXCEPT
15702  {
15703  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDebugMarkerEndEXT && "Function <vkCmdDebugMarkerEndEXT> requires <VK_EXT_debug_marker>" );
15704 
15705  getDispatcher()->vkCmdDebugMarkerEndEXT( static_cast<VkCommandBuffer>( m_commandBuffer ) );
15706  }
15707 
15708  VULKAN_HPP_INLINE void CommandBuffer::debugMarkerInsertEXT( const VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT & markerInfo ) const VULKAN_HPP_NOEXCEPT
15709  {
15710  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDebugMarkerInsertEXT && "Function <vkCmdDebugMarkerInsertEXT> requires <VK_EXT_debug_marker>" );
15711 
15712  getDispatcher()->vkCmdDebugMarkerInsertEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
15713  reinterpret_cast<const VkDebugMarkerMarkerInfoEXT *>( &markerInfo ) );
15714  }
15715 
15716  //=== VK_KHR_video_queue ===
15717 
15718  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR
15719  PhysicalDevice::getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile ) const
15720  {
15722  "Function <vkGetPhysicalDeviceVideoCapabilitiesKHR> requires <VK_KHR_video_queue>" );
15723 
15724  VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR capabilities;
15726  getDispatcher()->vkGetPhysicalDeviceVideoCapabilitiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
15727  reinterpret_cast<const VkVideoProfileInfoKHR *>( &videoProfile ),
15728  reinterpret_cast<VkVideoCapabilitiesKHR *>( &capabilities ) ) );
15729  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR" );
15730 
15731  return capabilities;
15732  }
15733 
15734  template <typename X, typename Y, typename... Z>
15735  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
15736  PhysicalDevice::getVideoCapabilitiesKHR( const VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR & videoProfile ) const
15737  {
15739  "Function <vkGetPhysicalDeviceVideoCapabilitiesKHR> requires <VK_KHR_video_queue>" );
15740 
15741  StructureChain<X, Y, Z...> structureChain;
15742  VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR & capabilities = structureChain.template get<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>();
15744  getDispatcher()->vkGetPhysicalDeviceVideoCapabilitiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
15745  reinterpret_cast<const VkVideoProfileInfoKHR *>( &videoProfile ),
15746  reinterpret_cast<VkVideoCapabilitiesKHR *>( &capabilities ) ) );
15747  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR" );
15748 
15749  return structureChain;
15750  }
15751 
15752  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>
15753  PhysicalDevice::getVideoFormatPropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo ) const
15754  {
15756  "Function <vkGetPhysicalDeviceVideoFormatPropertiesKHR> requires <VK_KHR_video_queue>" );
15757 
15758  std::vector<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR> videoFormatProperties;
15759  uint32_t videoFormatPropertyCount;
15761  do
15762  {
15763  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
15764  getDispatcher()->vkGetPhysicalDeviceVideoFormatPropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
15765  reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ),
15766  &videoFormatPropertyCount,
15767  nullptr ) );
15768  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && videoFormatPropertyCount )
15769  {
15770  videoFormatProperties.resize( videoFormatPropertyCount );
15771  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
15772  getDispatcher()->vkGetPhysicalDeviceVideoFormatPropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
15773  reinterpret_cast<const VkPhysicalDeviceVideoFormatInfoKHR *>( &videoFormatInfo ),
15774  &videoFormatPropertyCount,
15775  reinterpret_cast<VkVideoFormatPropertiesKHR *>( videoFormatProperties.data() ) ) );
15776  }
15777  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
15778  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoFormatPropertiesKHR" );
15779  VULKAN_HPP_ASSERT( videoFormatPropertyCount <= videoFormatProperties.size() );
15780  if ( videoFormatPropertyCount < videoFormatProperties.size() )
15781  {
15782  videoFormatProperties.resize( videoFormatPropertyCount );
15783  }
15784  return videoFormatProperties;
15785  }
15786 
15788  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::VideoSessionKHR>::Type
15789  Device::createVideoSessionKHR( VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const & createInfo,
15790  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
15792  {
15793  VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession;
15794  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateVideoSessionKHR(
15795  static_cast<VkDevice>( m_device ),
15796  reinterpret_cast<const VkVideoSessionCreateInfoKHR *>( &createInfo ),
15797  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
15798  reinterpret_cast<VkVideoSessionKHR *>( &videoSession ) ) );
15799  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
15800  {
15801 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
15802  return VULKAN_HPP_UNEXPECTED( result );
15803 # else
15804  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createVideoSessionKHR" );
15805 # endif
15806  }
15807 
15808  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::VideoSessionKHR( *this, *reinterpret_cast<VkVideoSessionKHR *>( &videoSession ), allocator );
15809  }
15810 
15811  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR> VideoSessionKHR::getMemoryRequirements() const
15812  {
15814  "Function <vkGetVideoSessionMemoryRequirementsKHR> requires <VK_KHR_video_queue>" );
15815 
15816  std::vector<VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR> memoryRequirements;
15817  uint32_t memoryRequirementsCount;
15819  do
15820  {
15821  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetVideoSessionMemoryRequirementsKHR(
15822  static_cast<VkDevice>( m_device ), static_cast<VkVideoSessionKHR>( m_videoSession ), &memoryRequirementsCount, nullptr ) );
15823  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && memoryRequirementsCount )
15824  {
15825  memoryRequirements.resize( memoryRequirementsCount );
15826  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
15827  getDispatcher()->vkGetVideoSessionMemoryRequirementsKHR( static_cast<VkDevice>( m_device ),
15828  static_cast<VkVideoSessionKHR>( m_videoSession ),
15829  &memoryRequirementsCount,
15830  reinterpret_cast<VkVideoSessionMemoryRequirementsKHR *>( memoryRequirements.data() ) ) );
15831  }
15832  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
15833 
15834  VULKAN_HPP_ASSERT( memoryRequirementsCount <= memoryRequirements.size() );
15835  if ( memoryRequirementsCount < memoryRequirements.size() )
15836  {
15837  memoryRequirements.resize( memoryRequirementsCount );
15838  }
15839  return memoryRequirements;
15840  }
15841 
15842  VULKAN_HPP_INLINE void VideoSessionKHR::bindMemory(
15843  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR> const & bindSessionMemoryInfos ) const
15844  {
15845  VULKAN_HPP_ASSERT( getDispatcher()->vkBindVideoSessionMemoryKHR && "Function <vkBindVideoSessionMemoryKHR> requires <VK_KHR_video_queue>" );
15846 
15848  getDispatcher()->vkBindVideoSessionMemoryKHR( static_cast<VkDevice>( m_device ),
15849  static_cast<VkVideoSessionKHR>( m_videoSession ),
15850  bindSessionMemoryInfos.size(),
15851  reinterpret_cast<const VkBindVideoSessionMemoryInfoKHR *>( bindSessionMemoryInfos.data() ) ) );
15852  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::VideoSessionKHR::bindMemory" );
15853  }
15854 
15856  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::VideoSessionParametersKHR>::Type
15857  Device::createVideoSessionParametersKHR( VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR const & createInfo,
15858  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
15860  {
15861  VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters;
15862  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateVideoSessionParametersKHR(
15863  static_cast<VkDevice>( m_device ),
15864  reinterpret_cast<const VkVideoSessionParametersCreateInfoKHR *>( &createInfo ),
15865  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
15866  reinterpret_cast<VkVideoSessionParametersKHR *>( &videoSessionParameters ) ) );
15867  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
15868  {
15869 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
15870  return VULKAN_HPP_UNEXPECTED( result );
15871 # else
15872  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createVideoSessionParametersKHR" );
15873 # endif
15874  }
15875 
15876  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::VideoSessionParametersKHR(
15877  *this, *reinterpret_cast<VkVideoSessionParametersKHR *>( &videoSessionParameters ), allocator );
15878  }
15879 
15880  VULKAN_HPP_INLINE void VideoSessionParametersKHR::update( const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR & updateInfo ) const
15881  {
15882  VULKAN_HPP_ASSERT( getDispatcher()->vkUpdateVideoSessionParametersKHR && "Function <vkUpdateVideoSessionParametersKHR> requires <VK_KHR_video_queue>" );
15883 
15885  getDispatcher()->vkUpdateVideoSessionParametersKHR( static_cast<VkDevice>( m_device ),
15886  static_cast<VkVideoSessionParametersKHR>( m_videoSessionParameters ),
15887  reinterpret_cast<const VkVideoSessionParametersUpdateInfoKHR *>( &updateInfo ) ) );
15888  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::VideoSessionParametersKHR::update" );
15889  }
15890 
15891  VULKAN_HPP_INLINE void CommandBuffer::beginVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR & beginInfo ) const VULKAN_HPP_NOEXCEPT
15892  {
15893  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginVideoCodingKHR && "Function <vkCmdBeginVideoCodingKHR> requires <VK_KHR_video_queue>" );
15894 
15895  getDispatcher()->vkCmdBeginVideoCodingKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
15896  reinterpret_cast<const VkVideoBeginCodingInfoKHR *>( &beginInfo ) );
15897  }
15898 
15899  VULKAN_HPP_INLINE void CommandBuffer::endVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR & endCodingInfo ) const VULKAN_HPP_NOEXCEPT
15900  {
15901  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndVideoCodingKHR && "Function <vkCmdEndVideoCodingKHR> requires <VK_KHR_video_queue>" );
15902 
15903  getDispatcher()->vkCmdEndVideoCodingKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
15904  reinterpret_cast<const VkVideoEndCodingInfoKHR *>( &endCodingInfo ) );
15905  }
15906 
15907  VULKAN_HPP_INLINE void
15908  CommandBuffer::controlVideoCodingKHR( const VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR & codingControlInfo ) const VULKAN_HPP_NOEXCEPT
15909  {
15910  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdControlVideoCodingKHR && "Function <vkCmdControlVideoCodingKHR> requires <VK_KHR_video_queue>" );
15911 
15912  getDispatcher()->vkCmdControlVideoCodingKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
15913  reinterpret_cast<const VkVideoCodingControlInfoKHR *>( &codingControlInfo ) );
15914  }
15915 
15916  //=== VK_KHR_video_decode_queue ===
15917 
15918  VULKAN_HPP_INLINE void CommandBuffer::decodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR & decodeInfo ) const VULKAN_HPP_NOEXCEPT
15919  {
15920  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDecodeVideoKHR && "Function <vkCmdDecodeVideoKHR> requires <VK_KHR_video_decode_queue>" );
15921 
15922  getDispatcher()->vkCmdDecodeVideoKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkVideoDecodeInfoKHR *>( &decodeInfo ) );
15923  }
15924 
15925  //=== VK_EXT_transform_feedback ===
15926 
15927  VULKAN_HPP_INLINE void
15928  CommandBuffer::bindTransformFeedbackBuffersEXT( uint32_t firstBinding,
15929  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers,
15930  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
15931  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes ) const
15932  {
15934  "Function <vkCmdBindTransformFeedbackBuffersEXT> requires <VK_EXT_transform_feedback>" );
15935 # ifdef VULKAN_HPP_NO_EXCEPTIONS
15936  VULKAN_HPP_ASSERT( buffers.size() == offsets.size() );
15937  VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() );
15938 # else
15939  if ( buffers.size() != offsets.size() )
15940  {
15941  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != offsets.size()" );
15942  }
15943  if ( !sizes.empty() && buffers.size() != sizes.size() )
15944  {
15945  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != sizes.size()" );
15946  }
15947 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
15948 
15949  getDispatcher()->vkCmdBindTransformFeedbackBuffersEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
15950  firstBinding,
15951  buffers.size(),
15952  reinterpret_cast<const VkBuffer *>( buffers.data() ),
15953  reinterpret_cast<const VkDeviceSize *>( offsets.data() ),
15954  reinterpret_cast<const VkDeviceSize *>( sizes.data() ) );
15955  }
15956 
15957  VULKAN_HPP_INLINE void
15958  CommandBuffer::beginTransformFeedbackEXT( uint32_t firstCounterBuffer,
15959  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers,
15960  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets ) const
15961  {
15962  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginTransformFeedbackEXT && "Function <vkCmdBeginTransformFeedbackEXT> requires <VK_EXT_transform_feedback>" );
15963 # ifdef VULKAN_HPP_NO_EXCEPTIONS
15964  VULKAN_HPP_ASSERT( counterBufferOffsets.empty() || counterBuffers.size() == counterBufferOffsets.size() );
15965 # else
15966  if ( !counterBufferOffsets.empty() && counterBuffers.size() != counterBufferOffsets.size() )
15967  {
15968  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::beginTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" );
15969  }
15970 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
15971 
15972  getDispatcher()->vkCmdBeginTransformFeedbackEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
15973  firstCounterBuffer,
15974  counterBuffers.size(),
15975  reinterpret_cast<const VkBuffer *>( counterBuffers.data() ),
15976  reinterpret_cast<const VkDeviceSize *>( counterBufferOffsets.data() ) );
15977  }
15978 
15979  VULKAN_HPP_INLINE void
15980  CommandBuffer::endTransformFeedbackEXT( uint32_t firstCounterBuffer,
15981  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & counterBuffers,
15982  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & counterBufferOffsets ) const
15983  {
15984  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndTransformFeedbackEXT && "Function <vkCmdEndTransformFeedbackEXT> requires <VK_EXT_transform_feedback>" );
15985 # ifdef VULKAN_HPP_NO_EXCEPTIONS
15986  VULKAN_HPP_ASSERT( counterBufferOffsets.empty() || counterBuffers.size() == counterBufferOffsets.size() );
15987 # else
15988  if ( !counterBufferOffsets.empty() && counterBuffers.size() != counterBufferOffsets.size() )
15989  {
15990  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::endTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" );
15991  }
15992 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
15993 
15994  getDispatcher()->vkCmdEndTransformFeedbackEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
15995  firstCounterBuffer,
15996  counterBuffers.size(),
15997  reinterpret_cast<const VkBuffer *>( counterBuffers.data() ),
15998  reinterpret_cast<const VkDeviceSize *>( counterBufferOffsets.data() ) );
15999  }
16000 
16001  VULKAN_HPP_INLINE void CommandBuffer::beginQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool,
16002  uint32_t query,
16004  uint32_t index ) const VULKAN_HPP_NOEXCEPT
16005  {
16006  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginQueryIndexedEXT && "Function <vkCmdBeginQueryIndexedEXT> requires <VK_EXT_transform_feedback>" );
16007 
16008  getDispatcher()->vkCmdBeginQueryIndexedEXT(
16009  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ), index );
16010  }
16011 
16012  VULKAN_HPP_INLINE void
16013  CommandBuffer::endQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, uint32_t index ) const VULKAN_HPP_NOEXCEPT
16014  {
16015  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndQueryIndexedEXT && "Function <vkCmdEndQueryIndexedEXT> requires <VK_EXT_transform_feedback>" );
16016 
16017  getDispatcher()->vkCmdEndQueryIndexedEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkQueryPool>( queryPool ), query, index );
16018  }
16019 
16020  VULKAN_HPP_INLINE void CommandBuffer::drawIndirectByteCountEXT( uint32_t instanceCount,
16021  uint32_t firstInstance,
16022  VULKAN_HPP_NAMESPACE::Buffer counterBuffer,
16023  VULKAN_HPP_NAMESPACE::DeviceSize counterBufferOffset,
16024  uint32_t counterOffset,
16025  uint32_t vertexStride ) const VULKAN_HPP_NOEXCEPT
16026  {
16027  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndirectByteCountEXT && "Function <vkCmdDrawIndirectByteCountEXT> requires <VK_EXT_transform_feedback>" );
16028 
16029  getDispatcher()->vkCmdDrawIndirectByteCountEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
16030  instanceCount,
16031  firstInstance,
16032  static_cast<VkBuffer>( counterBuffer ),
16033  static_cast<VkDeviceSize>( counterBufferOffset ),
16034  counterOffset,
16035  vertexStride );
16036  }
16037 
16038  //=== VK_NVX_binary_import ===
16039 
16041  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CuModuleNVX>::Type
16042  Device::createCuModuleNVX( VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX const & createInfo,
16043  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
16045  {
16046  VULKAN_HPP_NAMESPACE::CuModuleNVX module;
16047  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateCuModuleNVX(
16048  static_cast<VkDevice>( m_device ),
16049  reinterpret_cast<const VkCuModuleCreateInfoNVX *>( &createInfo ),
16050  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
16051  reinterpret_cast<VkCuModuleNVX *>( &module ) ) );
16052  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
16053  {
16054 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
16055  return VULKAN_HPP_UNEXPECTED( result );
16056 # else
16057  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createCuModuleNVX" );
16058 # endif
16059  }
16060 
16061  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CuModuleNVX( *this, *reinterpret_cast<VkCuModuleNVX *>( &module ), allocator );
16062  }
16063 
16065  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CuFunctionNVX>::Type
16066  Device::createCuFunctionNVX( VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX const & createInfo,
16067  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
16069  {
16070  VULKAN_HPP_NAMESPACE::CuFunctionNVX function;
16071  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateCuFunctionNVX(
16072  static_cast<VkDevice>( m_device ),
16073  reinterpret_cast<const VkCuFunctionCreateInfoNVX *>( &createInfo ),
16074  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
16075  reinterpret_cast<VkCuFunctionNVX *>( &function ) ) );
16076  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
16077  {
16078 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
16079  return VULKAN_HPP_UNEXPECTED( result );
16080 # else
16081  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createCuFunctionNVX" );
16082 # endif
16083  }
16084 
16085  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CuFunctionNVX( *this, *reinterpret_cast<VkCuFunctionNVX *>( &function ), allocator );
16086  }
16087 
16088  VULKAN_HPP_INLINE void CommandBuffer::cuLaunchKernelNVX( const VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX & launchInfo ) const VULKAN_HPP_NOEXCEPT
16089  {
16090  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCuLaunchKernelNVX && "Function <vkCmdCuLaunchKernelNVX> requires <VK_NVX_binary_import>" );
16091 
16092  getDispatcher()->vkCmdCuLaunchKernelNVX( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCuLaunchInfoNVX *>( &launchInfo ) );
16093  }
16094 
16095  //=== VK_NVX_image_view_handle ===
16096 
16098  Device::getImageViewHandleNVX( const VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX & info ) const VULKAN_HPP_NOEXCEPT
16099  {
16100  VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageViewHandleNVX && "Function <vkGetImageViewHandleNVX> requires <VK_NVX_image_view_handle>" );
16101 
16102  uint32_t result =
16103  getDispatcher()->vkGetImageViewHandleNVX( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImageViewHandleInfoNVX *>( &info ) );
16104 
16105  return result;
16106  }
16107 
16108  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX ImageView::getAddressNVX() const
16109  {
16110  VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageViewAddressNVX && "Function <vkGetImageViewAddressNVX> requires <VK_NVX_image_view_handle>" );
16111 
16112  VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX properties;
16113  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetImageViewAddressNVX(
16114  static_cast<VkDevice>( m_device ), static_cast<VkImageView>( m_imageView ), reinterpret_cast<VkImageViewAddressPropertiesNVX *>( &properties ) ) );
16115  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::ImageView::getAddressNVX" );
16116 
16117  return properties;
16118  }
16119 
16120  //=== VK_AMD_draw_indirect_count ===
16121 
16122  VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer,
16124  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
16125  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
16126  uint32_t maxDrawCount,
16127  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
16128  {
16129  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndirectCountAMD &&
16130  "Function <vkCmdDrawIndirectCountAMD> requires <VK_AMD_draw_indirect_count> or <VK_KHR_draw_indirect_count> or <VK_VERSION_1_2>" );
16131 
16132  getDispatcher()->vkCmdDrawIndirectCountAMD( static_cast<VkCommandBuffer>( m_commandBuffer ),
16133  static_cast<VkBuffer>( buffer ),
16134  static_cast<VkDeviceSize>( offset ),
16135  static_cast<VkBuffer>( countBuffer ),
16136  static_cast<VkDeviceSize>( countBufferOffset ),
16137  maxDrawCount,
16138  stride );
16139  }
16140 
16141  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer,
16143  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
16144  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
16145  uint32_t maxDrawCount,
16146  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
16147  {
16149  getDispatcher()->vkCmdDrawIndexedIndirectCountAMD &&
16150  "Function <vkCmdDrawIndexedIndirectCountAMD> requires <VK_AMD_draw_indirect_count> or <VK_KHR_draw_indirect_count> or <VK_VERSION_1_2>" );
16151 
16152  getDispatcher()->vkCmdDrawIndexedIndirectCountAMD( static_cast<VkCommandBuffer>( m_commandBuffer ),
16153  static_cast<VkBuffer>( buffer ),
16154  static_cast<VkDeviceSize>( offset ),
16155  static_cast<VkBuffer>( countBuffer ),
16156  static_cast<VkDeviceSize>( countBufferOffset ),
16157  maxDrawCount,
16158  stride );
16159  }
16160 
16161  //=== VK_AMD_shader_info ===
16162 
16163  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<uint8_t> Pipeline::getShaderInfoAMD( VULKAN_HPP_NAMESPACE::ShaderStageFlagBits shaderStage,
16165  {
16166  VULKAN_HPP_ASSERT( getDispatcher()->vkGetShaderInfoAMD && "Function <vkGetShaderInfoAMD> requires <VK_AMD_shader_info>" );
16167 
16168  std::vector<uint8_t> info;
16169  size_t infoSize;
16171  do
16172  {
16173  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetShaderInfoAMD( static_cast<VkDevice>( m_device ),
16174  static_cast<VkPipeline>( m_pipeline ),
16175  static_cast<VkShaderStageFlagBits>( shaderStage ),
16176  static_cast<VkShaderInfoTypeAMD>( infoType ),
16177  &infoSize,
16178  nullptr ) );
16179  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && infoSize )
16180  {
16181  info.resize( infoSize );
16182  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetShaderInfoAMD( static_cast<VkDevice>( m_device ),
16183  static_cast<VkPipeline>( m_pipeline ),
16184  static_cast<VkShaderStageFlagBits>( shaderStage ),
16185  static_cast<VkShaderInfoTypeAMD>( infoType ),
16186  &infoSize,
16187  reinterpret_cast<void *>( info.data() ) ) );
16188  }
16189  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
16190  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getShaderInfoAMD" );
16191  VULKAN_HPP_ASSERT( infoSize <= info.size() );
16192  if ( infoSize < info.size() )
16193  {
16194  info.resize( infoSize );
16195  }
16196  return info;
16197  }
16198 
16199  //=== VK_KHR_dynamic_rendering ===
16200 
16201  VULKAN_HPP_INLINE void CommandBuffer::beginRenderingKHR( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo ) const VULKAN_HPP_NOEXCEPT
16202  {
16203  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginRenderingKHR &&
16204  "Function <vkCmdBeginRenderingKHR> requires <VK_KHR_dynamic_rendering> or <VK_VERSION_1_3>" );
16205 
16206  getDispatcher()->vkCmdBeginRenderingKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkRenderingInfo *>( &renderingInfo ) );
16207  }
16208 
16209  VULKAN_HPP_INLINE void CommandBuffer::endRenderingKHR() const VULKAN_HPP_NOEXCEPT
16210  {
16211  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndRenderingKHR && "Function <vkCmdEndRenderingKHR> requires <VK_KHR_dynamic_rendering> or <VK_VERSION_1_3>" );
16212 
16213  getDispatcher()->vkCmdEndRenderingKHR( static_cast<VkCommandBuffer>( m_commandBuffer ) );
16214  }
16215 
16216 # if defined( VK_USE_PLATFORM_GGP )
16217  //=== VK_GGP_stream_descriptor_surface ===
16218 
16220  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type
16221  Instance::createStreamDescriptorSurfaceGGP( VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP const & createInfo,
16222  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
16224  {
16225  VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
16226  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateStreamDescriptorSurfaceGGP(
16227  static_cast<VkInstance>( m_instance ),
16228  reinterpret_cast<const VkStreamDescriptorSurfaceCreateInfoGGP *>( &createInfo ),
16229  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
16230  reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
16231  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
16232  {
16233 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
16234  return VULKAN_HPP_UNEXPECTED( result );
16235 # else
16236  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Instance::createStreamDescriptorSurfaceGGP" );
16237 # endif
16238  }
16239 
16240  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, *reinterpret_cast<VkSurfaceKHR *>( &surface ), allocator );
16241  }
16242 # endif /*VK_USE_PLATFORM_GGP*/
16243 
16244  //=== VK_NV_external_memory_capabilities ===
16245 
16246  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV
16247  PhysicalDevice::getExternalImageFormatPropertiesNV( VULKAN_HPP_NAMESPACE::Format format,
16253  {
16255  "Function <vkGetPhysicalDeviceExternalImageFormatPropertiesNV> requires <VK_NV_external_memory_capabilities>" );
16256 
16257  VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV externalImageFormatProperties;
16258  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
16259  static_cast<VkPhysicalDevice>( m_physicalDevice ),
16260  static_cast<VkFormat>( format ),
16261  static_cast<VkImageType>( type ),
16262  static_cast<VkImageTiling>( tiling ),
16263  static_cast<VkImageUsageFlags>( usage ),
16264  static_cast<VkImageCreateFlags>( flags ),
16265  static_cast<VkExternalMemoryHandleTypeFlagsNV>( externalHandleType ),
16266  reinterpret_cast<VkExternalImageFormatPropertiesNV *>( &externalImageFormatProperties ) ) );
16267  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getExternalImageFormatPropertiesNV" );
16268 
16269  return externalImageFormatProperties;
16270  }
16271 
16272 # if defined( VK_USE_PLATFORM_WIN32_KHR )
16273  //=== VK_NV_external_memory_win32 ===
16274 
16275  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE HANDLE DeviceMemory::getMemoryWin32HandleNV( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV handleType ) const
16276  {
16277  VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryWin32HandleNV && "Function <vkGetMemoryWin32HandleNV> requires <VK_NV_external_memory_win32>" );
16278 
16279  HANDLE handle;
16280  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetMemoryWin32HandleNV(
16281  static_cast<VkDevice>( m_device ), static_cast<VkDeviceMemory>( m_memory ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( handleType ), &handle ) );
16282  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::DeviceMemory::getMemoryWin32HandleNV" );
16283 
16284  return handle;
16285  }
16286 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
16287 
16288  //=== VK_KHR_get_physical_device_properties2 ===
16289 
16290  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 PhysicalDevice::getFeatures2KHR() const VULKAN_HPP_NOEXCEPT
16291  {
16293  "Function <vkGetPhysicalDeviceFeatures2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
16294 
16295  VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 features;
16296  getDispatcher()->vkGetPhysicalDeviceFeatures2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
16297  reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) );
16298 
16299  return features;
16300  }
16301 
16302  template <typename X, typename Y, typename... Z>
16303  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> PhysicalDevice::getFeatures2KHR() const VULKAN_HPP_NOEXCEPT
16304  {
16306  "Function <vkGetPhysicalDeviceFeatures2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
16307 
16308  VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
16309  VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 & features = structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2>();
16310  getDispatcher()->vkGetPhysicalDeviceFeatures2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
16311  reinterpret_cast<VkPhysicalDeviceFeatures2 *>( &features ) );
16312 
16313  return structureChain;
16314  }
16315 
16316  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 PhysicalDevice::getProperties2KHR() const VULKAN_HPP_NOEXCEPT
16317  {
16319  "Function <vkGetPhysicalDeviceProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
16320 
16321  VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 properties;
16322  getDispatcher()->vkGetPhysicalDeviceProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
16323  reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) );
16324 
16325  return properties;
16326  }
16327 
16328  template <typename X, typename Y, typename... Z>
16329  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> PhysicalDevice::getProperties2KHR() const VULKAN_HPP_NOEXCEPT
16330  {
16332  "Function <vkGetPhysicalDeviceProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
16333 
16334  VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
16335  VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 & properties = structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2>();
16336  getDispatcher()->vkGetPhysicalDeviceProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
16337  reinterpret_cast<VkPhysicalDeviceProperties2 *>( &properties ) );
16338 
16339  return structureChain;
16340  }
16341 
16342  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::FormatProperties2
16343  PhysicalDevice::getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT
16344  {
16346  "Function <vkGetPhysicalDeviceFormatProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
16347 
16348  VULKAN_HPP_NAMESPACE::FormatProperties2 formatProperties;
16349  getDispatcher()->vkGetPhysicalDeviceFormatProperties2KHR(
16350  static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) );
16351 
16352  return formatProperties;
16353  }
16354 
16355  template <typename X, typename Y, typename... Z>
16356  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
16357  PhysicalDevice::getFormatProperties2KHR( VULKAN_HPP_NAMESPACE::Format format ) const VULKAN_HPP_NOEXCEPT
16358  {
16360  "Function <vkGetPhysicalDeviceFormatProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
16361 
16362  VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
16363  VULKAN_HPP_NAMESPACE::FormatProperties2 & formatProperties = structureChain.template get<VULKAN_HPP_NAMESPACE::FormatProperties2>();
16364  getDispatcher()->vkGetPhysicalDeviceFormatProperties2KHR(
16365  static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2 *>( &formatProperties ) );
16366 
16367  return structureChain;
16368  }
16369 
16370  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ImageFormatProperties2
16371  PhysicalDevice::getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const
16372  {
16374  "Function <vkGetPhysicalDeviceImageFormatProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
16375 
16376  VULKAN_HPP_NAMESPACE::ImageFormatProperties2 imageFormatProperties;
16378  getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
16379  reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ),
16380  reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) );
16381  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" );
16382 
16383  return imageFormatProperties;
16384  }
16385 
16386  template <typename X, typename Y, typename... Z>
16387  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
16388  PhysicalDevice::getImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const
16389  {
16391  "Function <vkGetPhysicalDeviceImageFormatProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
16392 
16393  StructureChain<X, Y, Z...> structureChain;
16394  VULKAN_HPP_NAMESPACE::ImageFormatProperties2 & imageFormatProperties = structureChain.template get<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>();
16396  getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
16397  reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2 *>( &imageFormatInfo ),
16398  reinterpret_cast<VkImageFormatProperties2 *>( &imageFormatProperties ) ) );
16399  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" );
16400 
16401  return structureChain;
16402  }
16403 
16404  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> PhysicalDevice::getQueueFamilyProperties2KHR() const
16405  {
16407  "Function <vkGetPhysicalDeviceQueueFamilyProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
16408 
16409  std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties;
16410  uint32_t queueFamilyPropertyCount;
16411  getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), &queueFamilyPropertyCount, nullptr );
16412  queueFamilyProperties.resize( queueFamilyPropertyCount );
16413  getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
16414  &queueFamilyPropertyCount,
16415  reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
16416 
16417  VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
16418  if ( queueFamilyPropertyCount < queueFamilyProperties.size() )
16419  {
16420  queueFamilyProperties.resize( queueFamilyPropertyCount );
16421  }
16422  return queueFamilyProperties;
16423  }
16424 
16425  template <typename StructureChain>
16426  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain> PhysicalDevice::getQueueFamilyProperties2KHR() const
16427  {
16429  "Function <vkGetPhysicalDeviceQueueFamilyProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
16430 
16431  std::vector<StructureChain> structureChains;
16432  std::vector<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2> queueFamilyProperties;
16433  uint32_t queueFamilyPropertyCount;
16434  getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), &queueFamilyPropertyCount, nullptr );
16435  structureChains.resize( queueFamilyPropertyCount );
16436  queueFamilyProperties.resize( queueFamilyPropertyCount );
16437  for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
16438  {
16439  queueFamilyProperties[i].pNext = structureChains[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>().pNext;
16440  }
16441  getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
16442  &queueFamilyPropertyCount,
16443  reinterpret_cast<VkQueueFamilyProperties2 *>( queueFamilyProperties.data() ) );
16444 
16445  VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() );
16446  if ( queueFamilyPropertyCount < queueFamilyProperties.size() )
16447  {
16448  structureChains.resize( queueFamilyPropertyCount );
16449  }
16450  for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ )
16451  {
16452  structureChains[i].template get<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>() = queueFamilyProperties[i];
16453  }
16454  return structureChains;
16455  }
16456 
16457  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2
16458  PhysicalDevice::getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT
16459  {
16461  "Function <vkGetPhysicalDeviceMemoryProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
16462 
16463  VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 memoryProperties;
16464  getDispatcher()->vkGetPhysicalDeviceMemoryProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
16465  reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) );
16466 
16467  return memoryProperties;
16468  }
16469 
16470  template <typename X, typename Y, typename... Z>
16471  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> PhysicalDevice::getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT
16472  {
16474  "Function <vkGetPhysicalDeviceMemoryProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
16475 
16476  VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
16477  VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 & memoryProperties =
16478  structureChain.template get<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2>();
16479  getDispatcher()->vkGetPhysicalDeviceMemoryProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
16480  reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( &memoryProperties ) );
16481 
16482  return structureChain;
16483  }
16484 
16485  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>
16486  PhysicalDevice::getSparseImageFormatProperties2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 & formatInfo ) const
16487  {
16490  "Function <vkGetPhysicalDeviceSparseImageFormatProperties2KHR> requires <VK_KHR_get_physical_device_properties2> or <VK_VERSION_1_1>" );
16491 
16492  std::vector<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2> properties;
16493  uint32_t propertyCount;
16494  getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
16495  reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
16496  &propertyCount,
16497  nullptr );
16498  properties.resize( propertyCount );
16499  getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
16500  reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2 *>( &formatInfo ),
16501  &propertyCount,
16502  reinterpret_cast<VkSparseImageFormatProperties2 *>( properties.data() ) );
16503 
16504  VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
16505  if ( propertyCount < properties.size() )
16506  {
16507  properties.resize( propertyCount );
16508  }
16509  return properties;
16510  }
16511 
16512  //=== VK_KHR_device_group ===
16513 
16515  Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex ) const VULKAN_HPP_NOEXCEPT
16516  {
16518  "Function <vkGetDeviceGroupPeerMemoryFeaturesKHR> requires <VK_KHR_device_group> or <VK_VERSION_1_1>" );
16519 
16521  getDispatcher()->vkGetDeviceGroupPeerMemoryFeaturesKHR( static_cast<VkDevice>( m_device ),
16522  heapIndex,
16523  localDeviceIndex,
16524  remoteDeviceIndex,
16525  reinterpret_cast<VkPeerMemoryFeatureFlags *>( &peerMemoryFeatures ) );
16526 
16527  return peerMemoryFeatures;
16528  }
16529 
16530  VULKAN_HPP_INLINE void CommandBuffer::setDeviceMaskKHR( uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT
16531  {
16532  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDeviceMaskKHR && "Function <vkCmdSetDeviceMaskKHR> requires <VK_KHR_device_group> or <VK_VERSION_1_1>" );
16533 
16534  getDispatcher()->vkCmdSetDeviceMaskKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), deviceMask );
16535  }
16536 
16537  VULKAN_HPP_INLINE void CommandBuffer::dispatchBaseKHR( uint32_t baseGroupX,
16538  uint32_t baseGroupY,
16539  uint32_t baseGroupZ,
16540  uint32_t groupCountX,
16541  uint32_t groupCountY,
16542  uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
16543  {
16544  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatchBaseKHR && "Function <vkCmdDispatchBaseKHR> requires <VK_KHR_device_group> or <VK_VERSION_1_1>" );
16545 
16546  getDispatcher()->vkCmdDispatchBaseKHR(
16547  static_cast<VkCommandBuffer>( m_commandBuffer ), baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
16548  }
16549 
16550 # if defined( VK_USE_PLATFORM_VI_NN )
16551  //=== VK_NN_vi_surface ===
16552 
16554  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type
16555  Instance::createViSurfaceNN( VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN const & createInfo,
16556  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
16558  {
16559  VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
16560  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateViSurfaceNN(
16561  static_cast<VkInstance>( m_instance ),
16562  reinterpret_cast<const VkViSurfaceCreateInfoNN *>( &createInfo ),
16563  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
16564  reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
16565  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
16566  {
16567 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
16568  return VULKAN_HPP_UNEXPECTED( result );
16569 # else
16570  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Instance::createViSurfaceNN" );
16571 # endif
16572  }
16573 
16574  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, *reinterpret_cast<VkSurfaceKHR *>( &surface ), allocator );
16575  }
16576 # endif /*VK_USE_PLATFORM_VI_NN*/
16577 
16578  //=== VK_KHR_maintenance1 ===
16579 
16581  {
16582  VULKAN_HPP_ASSERT( getDispatcher()->vkTrimCommandPoolKHR && "Function <vkTrimCommandPoolKHR> requires <VK_KHR_maintenance1> or <VK_VERSION_1_1>" );
16583 
16584  getDispatcher()->vkTrimCommandPoolKHR(
16585  static_cast<VkDevice>( m_device ), static_cast<VkCommandPool>( m_commandPool ), static_cast<VkCommandPoolTrimFlags>( flags ) );
16586  }
16587 
16588  //=== VK_KHR_device_group_creation ===
16589 
16590  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> Instance::enumeratePhysicalDeviceGroupsKHR() const
16591  {
16593  "Function <vkEnumeratePhysicalDeviceGroupsKHR> requires <VK_KHR_device_group_creation> or <VK_VERSION_1_1>" );
16594 
16595  std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties> physicalDeviceGroupProperties;
16596  uint32_t physicalDeviceGroupCount;
16598  do
16599  {
16600  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
16601  getDispatcher()->vkEnumeratePhysicalDeviceGroupsKHR( static_cast<VkInstance>( m_instance ), &physicalDeviceGroupCount, nullptr ) );
16602  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && physicalDeviceGroupCount )
16603  {
16604  physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
16605  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumeratePhysicalDeviceGroupsKHR(
16606  static_cast<VkInstance>( m_instance ),
16607  &physicalDeviceGroupCount,
16608  reinterpret_cast<VkPhysicalDeviceGroupProperties *>( physicalDeviceGroupProperties.data() ) ) );
16609  }
16610  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
16611  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroupsKHR" );
16612  VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() );
16613  if ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() )
16614  {
16615  physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
16616  }
16617  return physicalDeviceGroupProperties;
16618  }
16619 
16620  //=== VK_KHR_external_memory_capabilities ===
16621 
16622  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalBufferProperties PhysicalDevice::getExternalBufferPropertiesKHR(
16623  const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo & externalBufferInfo ) const VULKAN_HPP_NOEXCEPT
16624  {
16626  "Function <vkGetPhysicalDeviceExternalBufferPropertiesKHR> requires <VK_KHR_external_memory_capabilities> or <VK_VERSION_1_1>" );
16627 
16628  VULKAN_HPP_NAMESPACE::ExternalBufferProperties externalBufferProperties;
16629  getDispatcher()->vkGetPhysicalDeviceExternalBufferPropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
16630  reinterpret_cast<const VkPhysicalDeviceExternalBufferInfo *>( &externalBufferInfo ),
16631  reinterpret_cast<VkExternalBufferProperties *>( &externalBufferProperties ) );
16632 
16633  return externalBufferProperties;
16634  }
16635 
16636 # if defined( VK_USE_PLATFORM_WIN32_KHR )
16637  //=== VK_KHR_external_memory_win32 ===
16638 
16640  Device::getMemoryWin32HandleKHR( const VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR & getWin32HandleInfo ) const
16641  {
16642  VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryWin32HandleKHR && "Function <vkGetMemoryWin32HandleKHR> requires <VK_KHR_external_memory_win32>" );
16643 
16644  HANDLE handle;
16645  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetMemoryWin32HandleKHR(
16646  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR *>( &getWin32HandleInfo ), &handle ) );
16647  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandleKHR" );
16648 
16649  return handle;
16650  }
16651 
16652  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR
16653  Device::getMemoryWin32HandlePropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle ) const
16654  {
16655  VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryWin32HandlePropertiesKHR &&
16656  "Function <vkGetMemoryWin32HandlePropertiesKHR> requires <VK_KHR_external_memory_win32>" );
16657 
16658  VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR memoryWin32HandleProperties;
16660  getDispatcher()->vkGetMemoryWin32HandlePropertiesKHR( static_cast<VkDevice>( m_device ),
16661  static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
16662  handle,
16663  reinterpret_cast<VkMemoryWin32HandlePropertiesKHR *>( &memoryWin32HandleProperties ) ) );
16664  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandlePropertiesKHR" );
16665 
16666  return memoryWin32HandleProperties;
16667  }
16668 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
16669 
16670  //=== VK_KHR_external_memory_fd ===
16671 
16672  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE int Device::getMemoryFdKHR( const VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR & getFdInfo ) const
16673  {
16674  VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryFdKHR && "Function <vkGetMemoryFdKHR> requires <VK_KHR_external_memory_fd>" );
16675 
16676  int fd;
16678  getDispatcher()->vkGetMemoryFdKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryGetFdInfoKHR *>( &getFdInfo ), &fd ) );
16679  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdKHR" );
16680 
16681  return fd;
16682  }
16683 
16684  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR
16685  Device::getMemoryFdPropertiesKHR( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, int fd ) const
16686  {
16687  VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryFdPropertiesKHR && "Function <vkGetMemoryFdPropertiesKHR> requires <VK_KHR_external_memory_fd>" );
16688 
16689  VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR memoryFdProperties;
16691  getDispatcher()->vkGetMemoryFdPropertiesKHR( static_cast<VkDevice>( m_device ),
16692  static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
16693  fd,
16694  reinterpret_cast<VkMemoryFdPropertiesKHR *>( &memoryFdProperties ) ) );
16695  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdPropertiesKHR" );
16696 
16697  return memoryFdProperties;
16698  }
16699 
16700  //=== VK_KHR_external_semaphore_capabilities ===
16701 
16702  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties PhysicalDevice::getExternalSemaphorePropertiesKHR(
16703  const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT
16704  {
16706  "Function <vkGetPhysicalDeviceExternalSemaphorePropertiesKHR> requires <VK_KHR_external_semaphore_capabilities> or <VK_VERSION_1_1>" );
16707 
16708  VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties externalSemaphoreProperties;
16709  getDispatcher()->vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
16710  static_cast<VkPhysicalDevice>( m_physicalDevice ),
16711  reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfo *>( &externalSemaphoreInfo ),
16712  reinterpret_cast<VkExternalSemaphoreProperties *>( &externalSemaphoreProperties ) );
16713 
16714  return externalSemaphoreProperties;
16715  }
16716 
16717 # if defined( VK_USE_PLATFORM_WIN32_KHR )
16718  //=== VK_KHR_external_semaphore_win32 ===
16719 
16720  VULKAN_HPP_INLINE void
16721  Device::importSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo ) const
16722  {
16723  VULKAN_HPP_ASSERT( getDispatcher()->vkImportSemaphoreWin32HandleKHR &&
16724  "Function <vkImportSemaphoreWin32HandleKHR> requires <VK_KHR_external_semaphore_win32>" );
16725 
16726  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkImportSemaphoreWin32HandleKHR(
16727  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR *>( &importSemaphoreWin32HandleInfo ) ) );
16728  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreWin32HandleKHR" );
16729  }
16730 
16732  Device::getSemaphoreWin32HandleKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo ) const
16733  {
16734  VULKAN_HPP_ASSERT( getDispatcher()->vkGetSemaphoreWin32HandleKHR &&
16735  "Function <vkGetSemaphoreWin32HandleKHR> requires <VK_KHR_external_semaphore_win32>" );
16736 
16737  HANDLE handle;
16738  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetSemaphoreWin32HandleKHR(
16739  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR *>( &getWin32HandleInfo ), &handle ) );
16740  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreWin32HandleKHR" );
16741 
16742  return handle;
16743  }
16744 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
16745 
16746  //=== VK_KHR_external_semaphore_fd ===
16747 
16748  VULKAN_HPP_INLINE void Device::importSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo ) const
16749  {
16750  VULKAN_HPP_ASSERT( getDispatcher()->vkImportSemaphoreFdKHR && "Function <vkImportSemaphoreFdKHR> requires <VK_KHR_external_semaphore_fd>" );
16751 
16752  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkImportSemaphoreFdKHR(
16753  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImportSemaphoreFdInfoKHR *>( &importSemaphoreFdInfo ) ) );
16754  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreFdKHR" );
16755  }
16756 
16757  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE int Device::getSemaphoreFdKHR( const VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR & getFdInfo ) const
16758  {
16759  VULKAN_HPP_ASSERT( getDispatcher()->vkGetSemaphoreFdKHR && "Function <vkGetSemaphoreFdKHR> requires <VK_KHR_external_semaphore_fd>" );
16760 
16761  int fd;
16763  getDispatcher()->vkGetSemaphoreFdKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreGetFdInfoKHR *>( &getFdInfo ), &fd ) );
16764  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreFdKHR" );
16765 
16766  return fd;
16767  }
16768 
16769  //=== VK_KHR_push_descriptor ===
16770 
16771  VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR(
16772  VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
16773  VULKAN_HPP_NAMESPACE::PipelineLayout layout,
16774  uint32_t set,
16775  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::WriteDescriptorSet> const & descriptorWrites ) const VULKAN_HPP_NOEXCEPT
16776  {
16777  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushDescriptorSetKHR && "Function <vkCmdPushDescriptorSetKHR> requires <VK_KHR_push_descriptor>" );
16778 
16779  getDispatcher()->vkCmdPushDescriptorSetKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
16780  static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
16781  static_cast<VkPipelineLayout>( layout ),
16782  set,
16783  descriptorWrites.size(),
16784  reinterpret_cast<const VkWriteDescriptorSet *>( descriptorWrites.data() ) );
16785  }
16786 
16787  template <typename DataType>
16788  VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
16789  VULKAN_HPP_NAMESPACE::PipelineLayout layout,
16790  uint32_t set,
16791  DataType const & data ) const VULKAN_HPP_NOEXCEPT
16792  {
16794  "Function <vkCmdPushDescriptorSetWithTemplateKHR> requires <VK_KHR_descriptor_update_template> or <VK_KHR_push_descriptor>" );
16795 
16796  getDispatcher()->vkCmdPushDescriptorSetWithTemplateKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
16797  static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
16798  static_cast<VkPipelineLayout>( layout ),
16799  set,
16800  reinterpret_cast<const void *>( &data ) );
16801  }
16802 
16803  //=== VK_EXT_conditional_rendering ===
16804 
16805  VULKAN_HPP_INLINE void CommandBuffer::beginConditionalRenderingEXT(
16806  const VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin ) const VULKAN_HPP_NOEXCEPT
16807  {
16809  "Function <vkCmdBeginConditionalRenderingEXT> requires <VK_EXT_conditional_rendering>" );
16810 
16811  getDispatcher()->vkCmdBeginConditionalRenderingEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
16812  reinterpret_cast<const VkConditionalRenderingBeginInfoEXT *>( &conditionalRenderingBegin ) );
16813  }
16814 
16815  VULKAN_HPP_INLINE void CommandBuffer::endConditionalRenderingEXT() const VULKAN_HPP_NOEXCEPT
16816  {
16818  "Function <vkCmdEndConditionalRenderingEXT> requires <VK_EXT_conditional_rendering>" );
16819 
16820  getDispatcher()->vkCmdEndConditionalRenderingEXT( static_cast<VkCommandBuffer>( m_commandBuffer ) );
16821  }
16822 
16823  //=== VK_KHR_descriptor_update_template ===
16824 
16826  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate>::Type
16827  Device::createDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & createInfo,
16828  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
16830  {
16831  VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate;
16832  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateDescriptorUpdateTemplateKHR(
16833  static_cast<VkDevice>( m_device ),
16834  reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfo *>( &createInfo ),
16835  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
16836  reinterpret_cast<VkDescriptorUpdateTemplate *>( &descriptorUpdateTemplate ) ) );
16837  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
16838  {
16839 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
16840  return VULKAN_HPP_UNEXPECTED( result );
16841 # else
16842  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createDescriptorUpdateTemplateKHR" );
16843 # endif
16844  }
16845 
16846  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DescriptorUpdateTemplate(
16847  *this, *reinterpret_cast<VkDescriptorUpdateTemplate *>( &descriptorUpdateTemplate ), allocator );
16848  }
16849 
16850  VULKAN_HPP_INLINE void
16851  Device::destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
16853  {
16855  "Function <vkDestroyDescriptorUpdateTemplateKHR> requires <VK_KHR_descriptor_update_template> or <VK_VERSION_1_1>" );
16856 
16857  getDispatcher()->vkDestroyDescriptorUpdateTemplateKHR(
16858  static_cast<VkDevice>( m_device ),
16859  static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
16860  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
16861  }
16862 
16863  template <typename DataType>
16864  VULKAN_HPP_INLINE void DescriptorSet::updateWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate,
16865  DataType const & data ) const VULKAN_HPP_NOEXCEPT
16866  {
16868  "Function <vkUpdateDescriptorSetWithTemplateKHR> requires <VK_KHR_descriptor_update_template> or <VK_VERSION_1_1>" );
16869 
16870  getDispatcher()->vkUpdateDescriptorSetWithTemplateKHR( static_cast<VkDevice>( m_device ),
16871  static_cast<VkDescriptorSet>( m_descriptorSet ),
16872  static_cast<VkDescriptorUpdateTemplate>( descriptorUpdateTemplate ),
16873  reinterpret_cast<const void *>( &data ) );
16874  }
16875 
16876  //=== VK_NV_clip_space_w_scaling ===
16877 
16878  VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV(
16879  uint32_t firstViewport,
16880  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportWScalingNV> const & viewportWScalings ) const VULKAN_HPP_NOEXCEPT
16881  {
16882  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetViewportWScalingNV && "Function <vkCmdSetViewportWScalingNV> requires <VK_NV_clip_space_w_scaling>" );
16883 
16884  getDispatcher()->vkCmdSetViewportWScalingNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
16885  firstViewport,
16886  viewportWScalings.size(),
16887  reinterpret_cast<const VkViewportWScalingNV *>( viewportWScalings.data() ) );
16888  }
16889 
16890 # if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
16891  //=== VK_EXT_acquire_xlib_display ===
16892 
16893  VULKAN_HPP_INLINE void PhysicalDevice::acquireXlibDisplayEXT( Display & dpy, VULKAN_HPP_NAMESPACE::DisplayKHR display ) const
16894  {
16895  VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireXlibDisplayEXT && "Function <vkAcquireXlibDisplayEXT> requires <VK_EXT_acquire_xlib_display>" );
16896 
16898  getDispatcher()->vkAcquireXlibDisplayEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), &dpy, static_cast<VkDisplayKHR>( display ) ) );
16899  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireXlibDisplayEXT" );
16900  }
16901 
16903  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR>::Type
16904  PhysicalDevice::getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT
16905  {
16906  VULKAN_HPP_NAMESPACE::DisplayKHR display;
16907  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetRandROutputDisplayEXT(
16908  static_cast<VkPhysicalDevice>( m_physicalDevice ), &dpy, rrOutput, reinterpret_cast<VkDisplayKHR *>( &display ) ) );
16909  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
16910  {
16911 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
16912  return VULKAN_HPP_UNEXPECTED( result );
16913 # else
16914  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "PhysicalDevice::getRandROutputDisplayEXT" );
16915 # endif
16916  }
16917 
16918  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR( *this, *reinterpret_cast<VkDisplayKHR *>( &display ) );
16919  }
16920 # endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
16921 
16922  //=== VK_EXT_display_surface_counter ===
16923 
16924  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT
16925  PhysicalDevice::getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const
16926  {
16928  "Function <vkGetPhysicalDeviceSurfaceCapabilities2EXT> requires <VK_EXT_display_surface_counter>" );
16929 
16930  VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT surfaceCapabilities;
16932  getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2EXT( static_cast<VkPhysicalDevice>( m_physicalDevice ),
16933  static_cast<VkSurfaceKHR>( surface ),
16934  reinterpret_cast<VkSurfaceCapabilities2EXT *>( &surfaceCapabilities ) ) );
16935  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2EXT" );
16936 
16937  return surfaceCapabilities;
16938  }
16939 
16940  //=== VK_EXT_display_control ===
16941 
16942  VULKAN_HPP_INLINE void Device::displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display,
16943  const VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT & displayPowerInfo ) const
16944  {
16945  VULKAN_HPP_ASSERT( getDispatcher()->vkDisplayPowerControlEXT && "Function <vkDisplayPowerControlEXT> requires <VK_EXT_display_control>" );
16946 
16947  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkDisplayPowerControlEXT(
16948  static_cast<VkDevice>( m_device ), static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayPowerInfoEXT *>( &displayPowerInfo ) ) );
16949  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::displayPowerControlEXT" );
16950  }
16951 
16953  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Fence>::Type
16954  Device::registerEventEXT( VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT const & deviceEventInfo,
16955  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
16957  {
16958  VULKAN_HPP_NAMESPACE::Fence fence;
16959  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkRegisterDeviceEventEXT(
16960  static_cast<VkDevice>( m_device ),
16961  reinterpret_cast<const VkDeviceEventInfoEXT *>( &deviceEventInfo ),
16962  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
16963  reinterpret_cast<VkFence *>( &fence ) ) );
16964  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
16965  {
16966 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
16967  return VULKAN_HPP_UNEXPECTED( result );
16968 # else
16969  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::registerEventEXT" );
16970 # endif
16971  }
16972 
16973  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Fence( *this, *reinterpret_cast<VkFence *>( &fence ), allocator );
16974  }
16975 
16977  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Fence>::Type
16978  Device::registerDisplayEventEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR const & display,
16979  VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT const & displayEventInfo,
16980  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
16982  {
16983  VULKAN_HPP_NAMESPACE::Fence fence;
16984  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkRegisterDisplayEventEXT(
16985  static_cast<VkDevice>( m_device ),
16986  static_cast<VkDisplayKHR>( *display ),
16987  reinterpret_cast<const VkDisplayEventInfoEXT *>( &displayEventInfo ),
16988  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
16989  reinterpret_cast<VkFence *>( &fence ) ) );
16990  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
16991  {
16992 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
16993  return VULKAN_HPP_UNEXPECTED( result );
16994 # else
16995  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::registerDisplayEventEXT" );
16996 # endif
16997  }
16998 
16999  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Fence( *this, *reinterpret_cast<VkFence *>( &fence ), allocator );
17000  }
17001 
17003  {
17004  VULKAN_HPP_ASSERT( getDispatcher()->vkGetSwapchainCounterEXT && "Function <vkGetSwapchainCounterEXT> requires <VK_EXT_display_control>" );
17005 
17006  uint64_t counterValue;
17007  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetSwapchainCounterEXT(
17008  static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), static_cast<VkSurfaceCounterFlagBitsEXT>( counter ), &counterValue ) );
17009  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getCounterEXT" );
17010 
17011  return counterValue;
17012  }
17013 
17014  //=== VK_GOOGLE_display_timing ===
17015 
17016  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE SwapchainKHR::getRefreshCycleDurationGOOGLE() const
17017  {
17018  VULKAN_HPP_ASSERT( getDispatcher()->vkGetRefreshCycleDurationGOOGLE && "Function <vkGetRefreshCycleDurationGOOGLE> requires <VK_GOOGLE_display_timing>" );
17019 
17020  VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE displayTimingProperties;
17022  getDispatcher()->vkGetRefreshCycleDurationGOOGLE( static_cast<VkDevice>( m_device ),
17023  static_cast<VkSwapchainKHR>( m_swapchain ),
17024  reinterpret_cast<VkRefreshCycleDurationGOOGLE *>( &displayTimingProperties ) ) );
17025  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getRefreshCycleDurationGOOGLE" );
17026 
17027  return displayTimingProperties;
17028  }
17029 
17030  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE> SwapchainKHR::getPastPresentationTimingGOOGLE() const
17031  {
17033  "Function <vkGetPastPresentationTimingGOOGLE> requires <VK_GOOGLE_display_timing>" );
17034 
17035  std::vector<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE> presentationTimings;
17036  uint32_t presentationTimingCount;
17038  do
17039  {
17040  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPastPresentationTimingGOOGLE(
17041  static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), &presentationTimingCount, nullptr ) );
17042  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && presentationTimingCount )
17043  {
17044  presentationTimings.resize( presentationTimingCount );
17045  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
17046  getDispatcher()->vkGetPastPresentationTimingGOOGLE( static_cast<VkDevice>( m_device ),
17047  static_cast<VkSwapchainKHR>( m_swapchain ),
17048  &presentationTimingCount,
17049  reinterpret_cast<VkPastPresentationTimingGOOGLE *>( presentationTimings.data() ) ) );
17050  }
17051  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
17052  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getPastPresentationTimingGOOGLE" );
17053  VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() );
17054  if ( presentationTimingCount < presentationTimings.size() )
17055  {
17056  presentationTimings.resize( presentationTimingCount );
17057  }
17058  return presentationTimings;
17059  }
17060 
17061  //=== VK_EXT_discard_rectangles ===
17062 
17063  VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT(
17064  uint32_t firstDiscardRectangle, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & discardRectangles ) const VULKAN_HPP_NOEXCEPT
17065  {
17066  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDiscardRectangleEXT && "Function <vkCmdSetDiscardRectangleEXT> requires <VK_EXT_discard_rectangles>" );
17067 
17068  getDispatcher()->vkCmdSetDiscardRectangleEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
17069  firstDiscardRectangle,
17070  discardRectangles.size(),
17071  reinterpret_cast<const VkRect2D *>( discardRectangles.data() ) );
17072  }
17073 
17074  VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 discardRectangleEnable ) const VULKAN_HPP_NOEXCEPT
17075  {
17077  "Function <vkCmdSetDiscardRectangleEnableEXT> requires <VK_EXT_discard_rectangles>" );
17078 
17079  getDispatcher()->vkCmdSetDiscardRectangleEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( discardRectangleEnable ) );
17080  }
17081 
17082  VULKAN_HPP_INLINE void
17083  CommandBuffer::setDiscardRectangleModeEXT( VULKAN_HPP_NAMESPACE::DiscardRectangleModeEXT discardRectangleMode ) const VULKAN_HPP_NOEXCEPT
17084  {
17086  "Function <vkCmdSetDiscardRectangleModeEXT> requires <VK_EXT_discard_rectangles>" );
17087 
17088  getDispatcher()->vkCmdSetDiscardRectangleModeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
17089  static_cast<VkDiscardRectangleModeEXT>( discardRectangleMode ) );
17090  }
17091 
17092  //=== VK_EXT_hdr_metadata ===
17093 
17094  VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SwapchainKHR> const & swapchains,
17095  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::HdrMetadataEXT> const & metadata ) const
17096  {
17097  VULKAN_HPP_ASSERT( getDispatcher()->vkSetHdrMetadataEXT && "Function <vkSetHdrMetadataEXT> requires <VK_EXT_hdr_metadata>" );
17098 # ifdef VULKAN_HPP_NO_EXCEPTIONS
17099  VULKAN_HPP_ASSERT( swapchains.size() == metadata.size() );
17100 # else
17101  if ( swapchains.size() != metadata.size() )
17102  {
17103  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::setHdrMetadataEXT: swapchains.size() != metadata.size()" );
17104  }
17105 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
17106 
17107  getDispatcher()->vkSetHdrMetadataEXT( static_cast<VkDevice>( m_device ),
17108  swapchains.size(),
17109  reinterpret_cast<const VkSwapchainKHR *>( swapchains.data() ),
17110  reinterpret_cast<const VkHdrMetadataEXT *>( metadata.data() ) );
17111  }
17112 
17113  //=== VK_KHR_create_renderpass2 ===
17114 
17116  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::RenderPass>::Type
17117  Device::createRenderPass2KHR( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & createInfo,
17118  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
17120  {
17121  VULKAN_HPP_NAMESPACE::RenderPass renderPass;
17122  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateRenderPass2KHR(
17123  static_cast<VkDevice>( m_device ),
17124  reinterpret_cast<const VkRenderPassCreateInfo2 *>( &createInfo ),
17125  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
17126  reinterpret_cast<VkRenderPass *>( &renderPass ) ) );
17127  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
17128  {
17129 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
17130  return VULKAN_HPP_UNEXPECTED( result );
17131 # else
17132  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createRenderPass2KHR" );
17133 # endif
17134  }
17135 
17136  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::RenderPass( *this, *reinterpret_cast<VkRenderPass *>( &renderPass ), allocator );
17137  }
17138 
17139  VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2KHR( const VULKAN_HPP_NAMESPACE::RenderPassBeginInfo & renderPassBegin,
17140  const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT
17141  {
17142  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginRenderPass2KHR &&
17143  "Function <vkCmdBeginRenderPass2KHR> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" );
17144 
17145  getDispatcher()->vkCmdBeginRenderPass2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
17146  reinterpret_cast<const VkRenderPassBeginInfo *>( &renderPassBegin ),
17147  reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ) );
17148  }
17149 
17150  VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2KHR( const VULKAN_HPP_NAMESPACE::SubpassBeginInfo & subpassBeginInfo,
17151  const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT
17152  {
17153  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdNextSubpass2KHR && "Function <vkCmdNextSubpass2KHR> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" );
17154 
17155  getDispatcher()->vkCmdNextSubpass2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
17156  reinterpret_cast<const VkSubpassBeginInfo *>( &subpassBeginInfo ),
17157  reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) );
17158  }
17159 
17160  VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR( const VULKAN_HPP_NAMESPACE::SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT
17161  {
17162  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndRenderPass2KHR &&
17163  "Function <vkCmdEndRenderPass2KHR> requires <VK_KHR_create_renderpass2> or <VK_VERSION_1_2>" );
17164 
17165  getDispatcher()->vkCmdEndRenderPass2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkSubpassEndInfo *>( &subpassEndInfo ) );
17166  }
17167 
17168  //=== VK_KHR_shared_presentable_image ===
17169 
17171  {
17172  VULKAN_HPP_ASSERT( getDispatcher()->vkGetSwapchainStatusKHR && "Function <vkGetSwapchainStatusKHR> requires <VK_KHR_shared_presentable_image>" );
17173 
17175  getDispatcher()->vkGetSwapchainStatusKHR( static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ) ) );
17176  resultCheck( result,
17177  VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getStatus",
17178  { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } );
17179 
17180  return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
17181  }
17182 
17183  //=== VK_KHR_external_fence_capabilities ===
17184 
17185  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExternalFenceProperties
17186  PhysicalDevice::getExternalFencePropertiesKHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo & externalFenceInfo ) const VULKAN_HPP_NOEXCEPT
17187  {
17189  "Function <vkGetPhysicalDeviceExternalFencePropertiesKHR> requires <VK_KHR_external_fence_capabilities> or <VK_VERSION_1_1>" );
17190 
17191  VULKAN_HPP_NAMESPACE::ExternalFenceProperties externalFenceProperties;
17192  getDispatcher()->vkGetPhysicalDeviceExternalFencePropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
17193  reinterpret_cast<const VkPhysicalDeviceExternalFenceInfo *>( &externalFenceInfo ),
17194  reinterpret_cast<VkExternalFenceProperties *>( &externalFenceProperties ) );
17195 
17196  return externalFenceProperties;
17197  }
17198 
17199 # if defined( VK_USE_PLATFORM_WIN32_KHR )
17200  //=== VK_KHR_external_fence_win32 ===
17201 
17202  VULKAN_HPP_INLINE void Device::importFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo ) const
17203  {
17204  VULKAN_HPP_ASSERT( getDispatcher()->vkImportFenceWin32HandleKHR && "Function <vkImportFenceWin32HandleKHR> requires <VK_KHR_external_fence_win32>" );
17205 
17206  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkImportFenceWin32HandleKHR(
17207  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImportFenceWin32HandleInfoKHR *>( &importFenceWin32HandleInfo ) ) );
17208  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importFenceWin32HandleKHR" );
17209  }
17210 
17212  Device::getFenceWin32HandleKHR( const VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR & getWin32HandleInfo ) const
17213  {
17214  VULKAN_HPP_ASSERT( getDispatcher()->vkGetFenceWin32HandleKHR && "Function <vkGetFenceWin32HandleKHR> requires <VK_KHR_external_fence_win32>" );
17215 
17216  HANDLE handle;
17217  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetFenceWin32HandleKHR(
17218  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkFenceGetWin32HandleInfoKHR *>( &getWin32HandleInfo ), &handle ) );
17219  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceWin32HandleKHR" );
17220 
17221  return handle;
17222  }
17223 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
17224 
17225  //=== VK_KHR_external_fence_fd ===
17226 
17227  VULKAN_HPP_INLINE void Device::importFenceFdKHR( const VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR & importFenceFdInfo ) const
17228  {
17229  VULKAN_HPP_ASSERT( getDispatcher()->vkImportFenceFdKHR && "Function <vkImportFenceFdKHR> requires <VK_KHR_external_fence_fd>" );
17230 
17232  getDispatcher()->vkImportFenceFdKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImportFenceFdInfoKHR *>( &importFenceFdInfo ) ) );
17233  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importFenceFdKHR" );
17234  }
17235 
17236  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE int Device::getFenceFdKHR( const VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR & getFdInfo ) const
17237  {
17238  VULKAN_HPP_ASSERT( getDispatcher()->vkGetFenceFdKHR && "Function <vkGetFenceFdKHR> requires <VK_KHR_external_fence_fd>" );
17239 
17240  int fd;
17242  getDispatcher()->vkGetFenceFdKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkFenceGetFdInfoKHR *>( &getFdInfo ), &fd ) );
17243  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceFdKHR" );
17244 
17245  return fd;
17246  }
17247 
17248  //=== VK_KHR_performance_query ===
17249 
17251  VULKAN_HPP_INLINE std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>, std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>>
17252  PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex ) const
17253  {
17255  "Function <vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR> requires <VK_KHR_performance_query>" );
17256 
17257  std::pair<std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>, std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>> data_;
17258  std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR> & counters = data_.first;
17259  std::vector<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR> & counterDescriptions = data_.second;
17260  uint32_t counterCount;
17262  do
17263  {
17264  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
17265  static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &counterCount, nullptr, nullptr ) );
17266  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && counterCount )
17267  {
17268  counters.resize( counterCount );
17269  counterDescriptions.resize( counterCount );
17270  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
17271  static_cast<VkPhysicalDevice>( m_physicalDevice ),
17272  queueFamilyIndex,
17273  &counterCount,
17274  reinterpret_cast<VkPerformanceCounterKHR *>( counters.data() ),
17275  reinterpret_cast<VkPerformanceCounterDescriptionKHR *>( counterDescriptions.data() ) ) );
17276  }
17277  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
17278  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR" );
17279  VULKAN_HPP_ASSERT( counterCount <= counters.size() );
17280  if ( counterCount < counters.size() )
17281  {
17282  counters.resize( counterCount );
17283  counterDescriptions.resize( counterCount );
17284  }
17285  return data_;
17286  }
17287 
17288  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t PhysicalDevice::getQueueFamilyPerformanceQueryPassesKHR(
17289  const VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo ) const VULKAN_HPP_NOEXCEPT
17290  {
17292  "Function <vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR> requires <VK_KHR_performance_query>" );
17293 
17294  uint32_t numPasses;
17295  getDispatcher()->vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
17296  static_cast<VkPhysicalDevice>( m_physicalDevice ),
17297  reinterpret_cast<const VkQueryPoolPerformanceCreateInfoKHR *>( &performanceQueryCreateInfo ),
17298  &numPasses );
17299 
17300  return numPasses;
17301  }
17302 
17303  VULKAN_HPP_INLINE void Device::acquireProfilingLockKHR( const VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR & info ) const
17304  {
17305  VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireProfilingLockKHR && "Function <vkAcquireProfilingLockKHR> requires <VK_KHR_performance_query>" );
17306 
17308  getDispatcher()->vkAcquireProfilingLockKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkAcquireProfilingLockInfoKHR *>( &info ) ) );
17309  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquireProfilingLockKHR" );
17310  }
17311 
17312  VULKAN_HPP_INLINE void Device::releaseProfilingLockKHR() const VULKAN_HPP_NOEXCEPT
17313  {
17314  VULKAN_HPP_ASSERT( getDispatcher()->vkReleaseProfilingLockKHR && "Function <vkReleaseProfilingLockKHR> requires <VK_KHR_performance_query>" );
17315 
17316  getDispatcher()->vkReleaseProfilingLockKHR( static_cast<VkDevice>( m_device ) );
17317  }
17318 
17319  //=== VK_KHR_get_surface_capabilities2 ===
17320 
17321  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR
17322  PhysicalDevice::getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const
17323  {
17325  "Function <vkGetPhysicalDeviceSurfaceCapabilities2KHR> requires <VK_KHR_get_surface_capabilities2>" );
17326 
17327  VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR surfaceCapabilities;
17329  getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
17330  reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
17331  reinterpret_cast<VkSurfaceCapabilities2KHR *>( &surfaceCapabilities ) ) );
17332  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2KHR" );
17333 
17334  return surfaceCapabilities;
17335  }
17336 
17337  template <typename X, typename Y, typename... Z>
17338  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
17339  PhysicalDevice::getSurfaceCapabilities2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const
17340  {
17342  "Function <vkGetPhysicalDeviceSurfaceCapabilities2KHR> requires <VK_KHR_get_surface_capabilities2>" );
17343 
17344  StructureChain<X, Y, Z...> structureChain;
17345  VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR & surfaceCapabilities = structureChain.template get<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR>();
17347  getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
17348  reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
17349  reinterpret_cast<VkSurfaceCapabilities2KHR *>( &surfaceCapabilities ) ) );
17350  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2KHR" );
17351 
17352  return structureChain;
17353  }
17354 
17355  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>
17356  PhysicalDevice::getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const
17357  {
17359  "Function <vkGetPhysicalDeviceSurfaceFormats2KHR> requires <VK_KHR_get_surface_capabilities2>" );
17360 
17361  std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR> surfaceFormats;
17362  uint32_t surfaceFormatCount;
17364  do
17365  {
17366  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
17367  getDispatcher()->vkGetPhysicalDeviceSurfaceFormats2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
17368  reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
17369  &surfaceFormatCount,
17370  nullptr ) );
17371  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && surfaceFormatCount )
17372  {
17373  surfaceFormats.resize( surfaceFormatCount );
17374  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
17375  getDispatcher()->vkGetPhysicalDeviceSurfaceFormats2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
17376  reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
17377  &surfaceFormatCount,
17378  reinterpret_cast<VkSurfaceFormat2KHR *>( surfaceFormats.data() ) ) );
17379  }
17380  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
17381  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormats2KHR" );
17382  VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
17383  if ( surfaceFormatCount < surfaceFormats.size() )
17384  {
17385  surfaceFormats.resize( surfaceFormatCount );
17386  }
17387  return surfaceFormats;
17388  }
17389 
17390  template <typename StructureChain>
17391  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<StructureChain>
17392  PhysicalDevice::getSurfaceFormats2KHR( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const
17393  {
17395  "Function <vkGetPhysicalDeviceSurfaceFormats2KHR> requires <VK_KHR_get_surface_capabilities2>" );
17396 
17397  std::vector<StructureChain> structureChains;
17398  std::vector<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR> surfaceFormats;
17399  uint32_t surfaceFormatCount;
17401  do
17402  {
17403  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
17404  getDispatcher()->vkGetPhysicalDeviceSurfaceFormats2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
17405  reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
17406  &surfaceFormatCount,
17407  nullptr ) );
17408  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && surfaceFormatCount )
17409  {
17410  structureChains.resize( surfaceFormatCount );
17411  surfaceFormats.resize( surfaceFormatCount );
17412  for ( uint32_t i = 0; i < surfaceFormatCount; i++ )
17413  {
17414  surfaceFormats[i].pNext = structureChains[i].template get<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>().pNext;
17415  }
17416  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
17417  getDispatcher()->vkGetPhysicalDeviceSurfaceFormats2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
17418  reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
17419  &surfaceFormatCount,
17420  reinterpret_cast<VkSurfaceFormat2KHR *>( surfaceFormats.data() ) ) );
17421  }
17422  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
17423  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormats2KHR" );
17424  VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() );
17425  if ( surfaceFormatCount < surfaceFormats.size() )
17426  {
17427  structureChains.resize( surfaceFormatCount );
17428  }
17429  for ( uint32_t i = 0; i < surfaceFormatCount; i++ )
17430  {
17431  structureChains[i].template get<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>() = surfaceFormats[i];
17432  }
17433  return structureChains;
17434  }
17435 
17436  //=== VK_KHR_get_display_properties2 ===
17437 
17438  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR> PhysicalDevice::getDisplayProperties2KHR() const
17439  {
17441  "Function <vkGetPhysicalDeviceDisplayProperties2KHR> requires <VK_KHR_get_display_properties2>" );
17442 
17443  std::vector<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR> properties;
17444  uint32_t propertyCount;
17446  do
17447  {
17448  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
17449  getDispatcher()->vkGetPhysicalDeviceDisplayProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, nullptr ) );
17450  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount )
17451  {
17452  properties.resize( propertyCount );
17453  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceDisplayProperties2KHR(
17454  static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, reinterpret_cast<VkDisplayProperties2KHR *>( properties.data() ) ) );
17455  }
17456  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
17457  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayProperties2KHR" );
17458  VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
17459  if ( propertyCount < properties.size() )
17460  {
17461  properties.resize( propertyCount );
17462  }
17463  return properties;
17464  }
17465 
17466  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR> PhysicalDevice::getDisplayPlaneProperties2KHR() const
17467  {
17469  "Function <vkGetPhysicalDeviceDisplayPlaneProperties2KHR> requires <VK_KHR_get_display_properties2>" );
17470 
17471  std::vector<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR> properties;
17472  uint32_t propertyCount;
17474  do
17475  {
17476  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
17477  getDispatcher()->vkGetPhysicalDeviceDisplayPlaneProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, nullptr ) );
17478  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount )
17479  {
17480  properties.resize( propertyCount );
17481  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
17482  static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, reinterpret_cast<VkDisplayPlaneProperties2KHR *>( properties.data() ) ) );
17483  }
17484  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
17485  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneProperties2KHR" );
17486  VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
17487  if ( propertyCount < properties.size() )
17488  {
17489  properties.resize( propertyCount );
17490  }
17491  return properties;
17492  }
17493 
17494  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR> DisplayKHR::getModeProperties2() const
17495  {
17497  "Function <vkGetDisplayModeProperties2KHR> requires <VK_KHR_get_display_properties2>" );
17498 
17499  std::vector<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR> properties;
17500  uint32_t propertyCount;
17502  do
17503  {
17504  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDisplayModeProperties2KHR(
17505  static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkDisplayKHR>( m_display ), &propertyCount, nullptr ) );
17506  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount )
17507  {
17508  properties.resize( propertyCount );
17509  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
17510  getDispatcher()->vkGetDisplayModeProperties2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
17511  static_cast<VkDisplayKHR>( m_display ),
17512  &propertyCount,
17513  reinterpret_cast<VkDisplayModeProperties2KHR *>( properties.data() ) ) );
17514  }
17515  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
17516  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::DisplayKHR::getModeProperties2" );
17517  VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
17518  if ( propertyCount < properties.size() )
17519  {
17520  properties.resize( propertyCount );
17521  }
17522  return properties;
17523  }
17524 
17525  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR
17526  PhysicalDevice::getDisplayPlaneCapabilities2KHR( const VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR & displayPlaneInfo ) const
17527  {
17529  "Function <vkGetDisplayPlaneCapabilities2KHR> requires <VK_KHR_get_display_properties2>" );
17530 
17531  VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR capabilities;
17533  getDispatcher()->vkGetDisplayPlaneCapabilities2KHR( static_cast<VkPhysicalDevice>( m_physicalDevice ),
17534  reinterpret_cast<const VkDisplayPlaneInfo2KHR *>( &displayPlaneInfo ),
17535  reinterpret_cast<VkDisplayPlaneCapabilities2KHR *>( &capabilities ) ) );
17536  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneCapabilities2KHR" );
17537 
17538  return capabilities;
17539  }
17540 
17541 # if defined( VK_USE_PLATFORM_IOS_MVK )
17542  //=== VK_MVK_ios_surface ===
17543 
17545  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type
17546  Instance::createIOSSurfaceMVK( VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK const & createInfo,
17547  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
17549  {
17550  VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
17551  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateIOSSurfaceMVK(
17552  static_cast<VkInstance>( m_instance ),
17553  reinterpret_cast<const VkIOSSurfaceCreateInfoMVK *>( &createInfo ),
17554  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
17555  reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
17556  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
17557  {
17558 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
17559  return VULKAN_HPP_UNEXPECTED( result );
17560 # else
17561  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Instance::createIOSSurfaceMVK" );
17562 # endif
17563  }
17564 
17565  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, *reinterpret_cast<VkSurfaceKHR *>( &surface ), allocator );
17566  }
17567 # endif /*VK_USE_PLATFORM_IOS_MVK*/
17568 
17569 # if defined( VK_USE_PLATFORM_MACOS_MVK )
17570  //=== VK_MVK_macos_surface ===
17571 
17573  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type
17574  Instance::createMacOSSurfaceMVK( VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK const & createInfo,
17575  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
17577  {
17578  VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
17579  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateMacOSSurfaceMVK(
17580  static_cast<VkInstance>( m_instance ),
17581  reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK *>( &createInfo ),
17582  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
17583  reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
17584  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
17585  {
17586 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
17587  return VULKAN_HPP_UNEXPECTED( result );
17588 # else
17589  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Instance::createMacOSSurfaceMVK" );
17590 # endif
17591  }
17592 
17593  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, *reinterpret_cast<VkSurfaceKHR *>( &surface ), allocator );
17594  }
17595 # endif /*VK_USE_PLATFORM_MACOS_MVK*/
17596 
17597  //=== VK_EXT_debug_utils ===
17598 
17599  VULKAN_HPP_INLINE void Device::setDebugUtilsObjectNameEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT & nameInfo ) const
17600  {
17601  VULKAN_HPP_ASSERT( getDispatcher()->vkSetDebugUtilsObjectNameEXT && "Function <vkSetDebugUtilsObjectNameEXT> requires <VK_EXT_debug_utils>" );
17602 
17603  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkSetDebugUtilsObjectNameEXT(
17604  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT *>( &nameInfo ) ) );
17605  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setDebugUtilsObjectNameEXT" );
17606  }
17607 
17608  VULKAN_HPP_INLINE void Device::setDebugUtilsObjectTagEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT & tagInfo ) const
17609  {
17610  VULKAN_HPP_ASSERT( getDispatcher()->vkSetDebugUtilsObjectTagEXT && "Function <vkSetDebugUtilsObjectTagEXT> requires <VK_EXT_debug_utils>" );
17611 
17613  getDispatcher()->vkSetDebugUtilsObjectTagEXT( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDebugUtilsObjectTagInfoEXT *>( &tagInfo ) ) );
17614  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setDebugUtilsObjectTagEXT" );
17615  }
17616 
17617  VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT
17618  {
17619  VULKAN_HPP_ASSERT( getDispatcher()->vkQueueBeginDebugUtilsLabelEXT && "Function <vkQueueBeginDebugUtilsLabelEXT> requires <VK_EXT_debug_utils>" );
17620 
17621  getDispatcher()->vkQueueBeginDebugUtilsLabelEXT( static_cast<VkQueue>( m_queue ), reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) );
17622  }
17623 
17624  VULKAN_HPP_INLINE void Queue::endDebugUtilsLabelEXT() const VULKAN_HPP_NOEXCEPT
17625  {
17626  VULKAN_HPP_ASSERT( getDispatcher()->vkQueueEndDebugUtilsLabelEXT && "Function <vkQueueEndDebugUtilsLabelEXT> requires <VK_EXT_debug_utils>" );
17627 
17628  getDispatcher()->vkQueueEndDebugUtilsLabelEXT( static_cast<VkQueue>( m_queue ) );
17629  }
17630 
17631  VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT
17632  {
17633  VULKAN_HPP_ASSERT( getDispatcher()->vkQueueInsertDebugUtilsLabelEXT && "Function <vkQueueInsertDebugUtilsLabelEXT> requires <VK_EXT_debug_utils>" );
17634 
17635  getDispatcher()->vkQueueInsertDebugUtilsLabelEXT( static_cast<VkQueue>( m_queue ), reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) );
17636  }
17637 
17638  VULKAN_HPP_INLINE void CommandBuffer::beginDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT
17639  {
17640  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginDebugUtilsLabelEXT && "Function <vkCmdBeginDebugUtilsLabelEXT> requires <VK_EXT_debug_utils>" );
17641 
17642  getDispatcher()->vkCmdBeginDebugUtilsLabelEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
17643  reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) );
17644  }
17645 
17646  VULKAN_HPP_INLINE void CommandBuffer::endDebugUtilsLabelEXT() const VULKAN_HPP_NOEXCEPT
17647  {
17648  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndDebugUtilsLabelEXT && "Function <vkCmdEndDebugUtilsLabelEXT> requires <VK_EXT_debug_utils>" );
17649 
17650  getDispatcher()->vkCmdEndDebugUtilsLabelEXT( static_cast<VkCommandBuffer>( m_commandBuffer ) );
17651  }
17652 
17653  VULKAN_HPP_INLINE void CommandBuffer::insertDebugUtilsLabelEXT( const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT
17654  {
17655  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdInsertDebugUtilsLabelEXT && "Function <vkCmdInsertDebugUtilsLabelEXT> requires <VK_EXT_debug_utils>" );
17656 
17657  getDispatcher()->vkCmdInsertDebugUtilsLabelEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
17658  reinterpret_cast<const VkDebugUtilsLabelEXT *>( &labelInfo ) );
17659  }
17660 
17662  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DebugUtilsMessengerEXT>::Type
17663  Instance::createDebugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT const & createInfo,
17664  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
17666  {
17667  VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger;
17668  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateDebugUtilsMessengerEXT(
17669  static_cast<VkInstance>( m_instance ),
17670  reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT *>( &createInfo ),
17671  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
17672  reinterpret_cast<VkDebugUtilsMessengerEXT *>( &messenger ) ) );
17673  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
17674  {
17675 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
17676  return VULKAN_HPP_UNEXPECTED( result );
17677 # else
17678  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Instance::createDebugUtilsMessengerEXT" );
17679 # endif
17680  }
17681 
17682  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DebugUtilsMessengerEXT(
17683  *this, *reinterpret_cast<VkDebugUtilsMessengerEXT *>( &messenger ), allocator );
17684  }
17685 
17686  VULKAN_HPP_INLINE void
17687  Instance::submitDebugUtilsMessageEXT( VULKAN_HPP_NAMESPACE::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
17689  const VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT & callbackData ) const VULKAN_HPP_NOEXCEPT
17690  {
17691  VULKAN_HPP_ASSERT( getDispatcher()->vkSubmitDebugUtilsMessageEXT && "Function <vkSubmitDebugUtilsMessageEXT> requires <VK_EXT_debug_utils>" );
17692 
17693  getDispatcher()->vkSubmitDebugUtilsMessageEXT( static_cast<VkInstance>( m_instance ),
17694  static_cast<VkDebugUtilsMessageSeverityFlagBitsEXT>( messageSeverity ),
17695  static_cast<VkDebugUtilsMessageTypeFlagsEXT>( messageTypes ),
17696  reinterpret_cast<const VkDebugUtilsMessengerCallbackDataEXT *>( &callbackData ) );
17697  }
17698 
17699 # if defined( VK_USE_PLATFORM_ANDROID_KHR )
17700  //=== VK_ANDROID_external_memory_android_hardware_buffer ===
17701 
17702  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID
17703  Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer ) const
17704  {
17705  VULKAN_HPP_ASSERT( getDispatcher()->vkGetAndroidHardwareBufferPropertiesANDROID &&
17706  "Function <vkGetAndroidHardwareBufferPropertiesANDROID> requires <VK_ANDROID_external_memory_android_hardware_buffer>" );
17707 
17708  VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID properties;
17709  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetAndroidHardwareBufferPropertiesANDROID(
17710  static_cast<VkDevice>( m_device ), &buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>( &properties ) ) );
17711  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID" );
17712 
17713  return properties;
17714  }
17715 
17716  template <typename X, typename Y, typename... Z>
17717  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
17718  Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer ) const
17719  {
17720  VULKAN_HPP_ASSERT( getDispatcher()->vkGetAndroidHardwareBufferPropertiesANDROID &&
17721  "Function <vkGetAndroidHardwareBufferPropertiesANDROID> requires <VK_ANDROID_external_memory_android_hardware_buffer>" );
17722 
17723  StructureChain<X, Y, Z...> structureChain;
17724  VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID & properties =
17725  structureChain.template get<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>();
17726  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetAndroidHardwareBufferPropertiesANDROID(
17727  static_cast<VkDevice>( m_device ), &buffer, reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>( &properties ) ) );
17728  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID" );
17729 
17730  return structureChain;
17731  }
17732 
17733  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE struct AHardwareBuffer *
17734  Device::getMemoryAndroidHardwareBufferANDROID( const VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID & info ) const
17735  {
17736  VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryAndroidHardwareBufferANDROID &&
17737  "Function <vkGetMemoryAndroidHardwareBufferANDROID> requires <VK_ANDROID_external_memory_android_hardware_buffer>" );
17738 
17739  struct AHardwareBuffer * buffer;
17740  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetMemoryAndroidHardwareBufferANDROID(
17741  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryGetAndroidHardwareBufferInfoANDROID *>( &info ), &buffer ) );
17742  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryAndroidHardwareBufferANDROID" );
17743 
17744  return buffer;
17745  }
17746 # endif /*VK_USE_PLATFORM_ANDROID_KHR*/
17747 
17748 # if defined( VK_ENABLE_BETA_EXTENSIONS )
17749  //=== VK_AMDX_shader_enqueue ===
17750 
17752  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>>::Type
17753  Device::createExecutionGraphPipelinesAMDX(
17754  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,
17755  VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX> const & createInfos,
17756  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
17757  {
17758  std::vector<VULKAN_HPP_NAMESPACE::Pipeline> pipelines( createInfos.size() );
17759  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateExecutionGraphPipelinesAMDX(
17760  static_cast<VkDevice>( m_device ),
17761  pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0,
17762  createInfos.size(),
17763  reinterpret_cast<const VkExecutionGraphPipelineCreateInfoAMDX *>( createInfos.data() ),
17764  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
17765  reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
17766  if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( result != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) )
17767  {
17768 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
17769  return VULKAN_HPP_UNEXPECTED( result );
17770 # else
17771  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createExecutionGraphPipelinesAMDX" );
17772 # endif
17773  }
17774 
17775  std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline> pipelinesRAII;
17776  pipelinesRAII.reserve( pipelines.size() );
17777  for ( auto & pipeline : pipelines )
17778  {
17779  pipelinesRAII.emplace_back( *this, *reinterpret_cast<VkPipeline *>( &pipeline ), allocator, result );
17780  }
17781  return pipelinesRAII;
17782  }
17783 
17785  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>::Type
17786  Device::createExecutionGraphPipelineAMDX(
17787  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,
17788  VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX const & createInfo,
17789  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT
17790  {
17791  VULKAN_HPP_NAMESPACE::Pipeline pipeline;
17792  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateExecutionGraphPipelinesAMDX(
17793  static_cast<VkDevice>( m_device ),
17794  pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0,
17795  1,
17796  reinterpret_cast<const VkExecutionGraphPipelineCreateInfoAMDX *>( &createInfo ),
17797  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
17798  reinterpret_cast<VkPipeline *>( &pipeline ) ) );
17799  if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( result != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) )
17800  {
17801 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
17802  return VULKAN_HPP_UNEXPECTED( result );
17803 # else
17804  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createExecutionGraphPipelineAMDX" );
17805 # endif
17806  }
17807 
17808  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline( *this, *reinterpret_cast<VkPipeline *>( &pipeline ), allocator );
17809  }
17810 
17811  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX Pipeline::getExecutionGraphScratchSizeAMDX() const
17812  {
17813  VULKAN_HPP_ASSERT( getDispatcher()->vkGetExecutionGraphPipelineScratchSizeAMDX &&
17814  "Function <vkGetExecutionGraphPipelineScratchSizeAMDX> requires <VK_AMDX_shader_enqueue>" );
17815 
17816  VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX sizeInfo;
17817  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetExecutionGraphPipelineScratchSizeAMDX(
17818  static_cast<VkDevice>( m_device ), static_cast<VkPipeline>( m_pipeline ), reinterpret_cast<VkExecutionGraphPipelineScratchSizeAMDX *>( &sizeInfo ) ) );
17819  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getExecutionGraphScratchSizeAMDX" );
17820 
17821  return sizeInfo;
17822  }
17823 
17825  Pipeline::getExecutionGraphNodeIndexAMDX( const VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX & nodeInfo ) const
17826  {
17827  VULKAN_HPP_ASSERT( getDispatcher()->vkGetExecutionGraphPipelineNodeIndexAMDX &&
17828  "Function <vkGetExecutionGraphPipelineNodeIndexAMDX> requires <VK_AMDX_shader_enqueue>" );
17829 
17830  uint32_t nodeIndex;
17832  getDispatcher()->vkGetExecutionGraphPipelineNodeIndexAMDX( static_cast<VkDevice>( m_device ),
17833  static_cast<VkPipeline>( m_pipeline ),
17834  reinterpret_cast<const VkPipelineShaderStageNodeCreateInfoAMDX *>( &nodeInfo ),
17835  &nodeIndex ) );
17836  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getExecutionGraphNodeIndexAMDX" );
17837 
17838  return nodeIndex;
17839  }
17840 
17841  VULKAN_HPP_INLINE void CommandBuffer::initializeGraphScratchMemoryAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch ) const VULKAN_HPP_NOEXCEPT
17842  {
17843  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdInitializeGraphScratchMemoryAMDX &&
17844  "Function <vkCmdInitializeGraphScratchMemoryAMDX> requires <VK_AMDX_shader_enqueue>" );
17845 
17846  getDispatcher()->vkCmdInitializeGraphScratchMemoryAMDX( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkDeviceAddress>( scratch ) );
17847  }
17848 
17849  VULKAN_HPP_INLINE void CommandBuffer::dispatchGraphAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch,
17850  const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX & countInfo ) const VULKAN_HPP_NOEXCEPT
17851  {
17852  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatchGraphAMDX && "Function <vkCmdDispatchGraphAMDX> requires <VK_AMDX_shader_enqueue>" );
17853 
17854  getDispatcher()->vkCmdDispatchGraphAMDX( static_cast<VkCommandBuffer>( m_commandBuffer ),
17855  static_cast<VkDeviceAddress>( scratch ),
17856  reinterpret_cast<const VkDispatchGraphCountInfoAMDX *>( &countInfo ) );
17857  }
17858 
17859  VULKAN_HPP_INLINE void
17860  CommandBuffer::dispatchGraphIndirectAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch,
17861  const VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX & countInfo ) const VULKAN_HPP_NOEXCEPT
17862  {
17863  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatchGraphIndirectAMDX && "Function <vkCmdDispatchGraphIndirectAMDX> requires <VK_AMDX_shader_enqueue>" );
17864 
17865  getDispatcher()->vkCmdDispatchGraphIndirectAMDX( static_cast<VkCommandBuffer>( m_commandBuffer ),
17866  static_cast<VkDeviceAddress>( scratch ),
17867  reinterpret_cast<const VkDispatchGraphCountInfoAMDX *>( &countInfo ) );
17868  }
17869 
17870  VULKAN_HPP_INLINE void CommandBuffer::dispatchGraphIndirectCountAMDX( VULKAN_HPP_NAMESPACE::DeviceAddress scratch,
17872  {
17873  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatchGraphIndirectCountAMDX &&
17874  "Function <vkCmdDispatchGraphIndirectCountAMDX> requires <VK_AMDX_shader_enqueue>" );
17875 
17876  getDispatcher()->vkCmdDispatchGraphIndirectCountAMDX(
17877  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkDeviceAddress>( scratch ), static_cast<VkDeviceAddress>( countInfo ) );
17878  }
17879 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
17880 
17881  //=== VK_EXT_sample_locations ===
17882 
17883  VULKAN_HPP_INLINE void
17884  CommandBuffer::setSampleLocationsEXT( const VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT & sampleLocationsInfo ) const VULKAN_HPP_NOEXCEPT
17885  {
17886  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetSampleLocationsEXT && "Function <vkCmdSetSampleLocationsEXT> requires <VK_EXT_sample_locations>" );
17887 
17888  getDispatcher()->vkCmdSetSampleLocationsEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
17889  reinterpret_cast<const VkSampleLocationsInfoEXT *>( &sampleLocationsInfo ) );
17890  }
17891 
17892  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT
17893  PhysicalDevice::getMultisamplePropertiesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples ) const VULKAN_HPP_NOEXCEPT
17894  {
17896  "Function <vkGetPhysicalDeviceMultisamplePropertiesEXT> requires <VK_EXT_sample_locations>" );
17897 
17898  VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT multisampleProperties;
17899  getDispatcher()->vkGetPhysicalDeviceMultisamplePropertiesEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ),
17900  static_cast<VkSampleCountFlagBits>( samples ),
17901  reinterpret_cast<VkMultisamplePropertiesEXT *>( &multisampleProperties ) );
17902 
17903  return multisampleProperties;
17904  }
17905 
17906  //=== VK_KHR_get_memory_requirements2 ===
17907 
17908  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2
17909  Device::getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT
17910  {
17912  "Function <vkGetImageMemoryRequirements2KHR> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" );
17913 
17914  VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
17915  getDispatcher()->vkGetImageMemoryRequirements2KHR( static_cast<VkDevice>( m_device ),
17916  reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ),
17917  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
17918 
17919  return memoryRequirements;
17920  }
17921 
17922  template <typename X, typename Y, typename... Z>
17923  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
17924  Device::getImageMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT
17925  {
17927  "Function <vkGetImageMemoryRequirements2KHR> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" );
17928 
17929  VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
17930  VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
17931  getDispatcher()->vkGetImageMemoryRequirements2KHR( static_cast<VkDevice>( m_device ),
17932  reinterpret_cast<const VkImageMemoryRequirementsInfo2 *>( &info ),
17933  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
17934 
17935  return structureChain;
17936  }
17937 
17938  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2
17939  Device::getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT
17940  {
17942  "Function <vkGetBufferMemoryRequirements2KHR> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" );
17943 
17944  VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
17945  getDispatcher()->vkGetBufferMemoryRequirements2KHR( static_cast<VkDevice>( m_device ),
17946  reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ),
17947  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
17948 
17949  return memoryRequirements;
17950  }
17951 
17952  template <typename X, typename Y, typename... Z>
17953  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
17954  Device::getBufferMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT
17955  {
17957  "Function <vkGetBufferMemoryRequirements2KHR> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" );
17958 
17959  VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
17960  VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
17961  getDispatcher()->vkGetBufferMemoryRequirements2KHR( static_cast<VkDevice>( m_device ),
17962  reinterpret_cast<const VkBufferMemoryRequirementsInfo2 *>( &info ),
17963  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
17964 
17965  return structureChain;
17966  }
17967 
17968  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>
17969  Device::getImageSparseMemoryRequirements2KHR( const VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 & info ) const
17970  {
17972  "Function <vkGetImageSparseMemoryRequirements2KHR> requires <VK_KHR_get_memory_requirements2> or <VK_VERSION_1_1>" );
17973 
17974  std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> sparseMemoryRequirements;
17975  uint32_t sparseMemoryRequirementCount;
17976  getDispatcher()->vkGetImageSparseMemoryRequirements2KHR(
17977  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ), &sparseMemoryRequirementCount, nullptr );
17978  sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
17979  getDispatcher()->vkGetImageSparseMemoryRequirements2KHR( static_cast<VkDevice>( m_device ),
17980  reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2 *>( &info ),
17981  &sparseMemoryRequirementCount,
17982  reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
17983 
17984  VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
17985  if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() )
17986  {
17987  sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
17988  }
17989  return sparseMemoryRequirements;
17990  }
17991 
17992  //=== VK_KHR_acceleration_structure ===
17993 
17995  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureKHR>::Type
17996  Device::createAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR const & createInfo,
17997  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
17999  {
18000  VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure;
18001  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateAccelerationStructureKHR(
18002  static_cast<VkDevice>( m_device ),
18003  reinterpret_cast<const VkAccelerationStructureCreateInfoKHR *>( &createInfo ),
18004  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
18005  reinterpret_cast<VkAccelerationStructureKHR *>( &accelerationStructure ) ) );
18006  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
18007  {
18008 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
18009  return VULKAN_HPP_UNEXPECTED( result );
18010 # else
18011  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createAccelerationStructureKHR" );
18012 # endif
18013  }
18014 
18015  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureKHR(
18016  *this, *reinterpret_cast<VkAccelerationStructureKHR *>( &accelerationStructure ), allocator );
18017  }
18018 
18019  VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresKHR(
18020  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,
18021  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos ) const
18022  {
18024  "Function <vkCmdBuildAccelerationStructuresKHR> requires <VK_KHR_acceleration_structure>" );
18025 # ifdef VULKAN_HPP_NO_EXCEPTIONS
18026  VULKAN_HPP_ASSERT( infos.size() == pBuildRangeInfos.size() );
18027 # else
18028  if ( infos.size() != pBuildRangeInfos.size() )
18029  {
18030  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::buildAccelerationStructuresKHR: infos.size() != pBuildRangeInfos.size()" );
18031  }
18032 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
18033 
18034  getDispatcher()->vkCmdBuildAccelerationStructuresKHR(
18035  static_cast<VkCommandBuffer>( m_commandBuffer ),
18036  infos.size(),
18037  reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( infos.data() ),
18038  reinterpret_cast<const VkAccelerationStructureBuildRangeInfoKHR * const *>( pBuildRangeInfos.data() ) );
18039  }
18040 
18041  VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresIndirectKHR(
18042  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,
18043  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceAddress> const & indirectDeviceAddresses,
18044  VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & indirectStrides,
18045  VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t * const> const & pMaxPrimitiveCounts ) const
18046  {
18048  "Function <vkCmdBuildAccelerationStructuresIndirectKHR> requires <VK_KHR_acceleration_structure>" );
18049 # ifdef VULKAN_HPP_NO_EXCEPTIONS
18050  VULKAN_HPP_ASSERT( infos.size() == indirectDeviceAddresses.size() );
18051  VULKAN_HPP_ASSERT( infos.size() == indirectStrides.size() );
18052  VULKAN_HPP_ASSERT( infos.size() == pMaxPrimitiveCounts.size() );
18053 # else
18054  if ( infos.size() != indirectDeviceAddresses.size() )
18055  {
18057  "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != indirectDeviceAddresses.size()" );
18058  }
18059  if ( infos.size() != indirectStrides.size() )
18060  {
18061  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != indirectStrides.size()" );
18062  }
18063  if ( infos.size() != pMaxPrimitiveCounts.size() )
18064  {
18065  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != pMaxPrimitiveCounts.size()" );
18066  }
18067 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
18068 
18069  getDispatcher()->vkCmdBuildAccelerationStructuresIndirectKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
18070  infos.size(),
18071  reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( infos.data() ),
18072  reinterpret_cast<const VkDeviceAddress *>( indirectDeviceAddresses.data() ),
18073  indirectStrides.data(),
18074  pMaxPrimitiveCounts.data() );
18075  }
18076 
18078  VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
18079  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR> const & infos,
18080  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR * const> const & pBuildRangeInfos ) const
18081  {
18083  "Function <vkBuildAccelerationStructuresKHR> requires <VK_KHR_acceleration_structure>" );
18084 # ifdef VULKAN_HPP_NO_EXCEPTIONS
18085  VULKAN_HPP_ASSERT( infos.size() == pBuildRangeInfos.size() );
18086 # else
18087  if ( infos.size() != pBuildRangeInfos.size() )
18088  {
18089  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::buildAccelerationStructuresKHR: infos.size() != pBuildRangeInfos.size()" );
18090  }
18091 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
18092 
18093  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkBuildAccelerationStructuresKHR(
18094  static_cast<VkDevice>( m_device ),
18095  static_cast<VkDeferredOperationKHR>( deferredOperation ),
18096  infos.size(),
18097  reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( infos.data() ),
18098  reinterpret_cast<const VkAccelerationStructureBuildRangeInfoKHR * const *>( pBuildRangeInfos.data() ) ) );
18099  resultCheck( result,
18100  VULKAN_HPP_NAMESPACE_STRING "::Device::buildAccelerationStructuresKHR",
18101  { VULKAN_HPP_NAMESPACE::Result::eSuccess,
18102  VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR,
18103  VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } );
18104 
18105  return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
18106  }
18107 
18109  Device::copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
18110  const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info ) const
18111  {
18113  "Function <vkCopyAccelerationStructureKHR> requires <VK_KHR_acceleration_structure>" );
18114 
18116  getDispatcher()->vkCopyAccelerationStructureKHR( static_cast<VkDevice>( m_device ),
18117  static_cast<VkDeferredOperationKHR>( deferredOperation ),
18118  reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>( &info ) ) );
18119  resultCheck( result,
18120  VULKAN_HPP_NAMESPACE_STRING "::Device::copyAccelerationStructureKHR",
18121  { VULKAN_HPP_NAMESPACE::Result::eSuccess,
18122  VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR,
18123  VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } );
18124 
18125  return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
18126  }
18127 
18129  Device::copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
18130  const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info ) const
18131  {
18133  "Function <vkCopyAccelerationStructureToMemoryKHR> requires <VK_KHR_acceleration_structure>" );
18134 
18136  getDispatcher()->vkCopyAccelerationStructureToMemoryKHR( static_cast<VkDevice>( m_device ),
18137  static_cast<VkDeferredOperationKHR>( deferredOperation ),
18138  reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>( &info ) ) );
18139  resultCheck( result,
18140  VULKAN_HPP_NAMESPACE_STRING "::Device::copyAccelerationStructureToMemoryKHR",
18141  { VULKAN_HPP_NAMESPACE::Result::eSuccess,
18142  VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR,
18143  VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } );
18144 
18145  return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
18146  }
18147 
18149  Device::copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
18150  const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info ) const
18151  {
18153  "Function <vkCopyMemoryToAccelerationStructureKHR> requires <VK_KHR_acceleration_structure>" );
18154 
18156  getDispatcher()->vkCopyMemoryToAccelerationStructureKHR( static_cast<VkDevice>( m_device ),
18157  static_cast<VkDeferredOperationKHR>( deferredOperation ),
18158  reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>( &info ) ) );
18159  resultCheck( result,
18160  VULKAN_HPP_NAMESPACE_STRING "::Device::copyMemoryToAccelerationStructureKHR",
18161  { VULKAN_HPP_NAMESPACE::Result::eSuccess,
18162  VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR,
18163  VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } );
18164 
18165  return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
18166  }
18167 
18168  template <typename DataType>
18169  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<DataType> Device::writeAccelerationStructuresPropertiesKHR(
18170  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
18172  size_t dataSize,
18173  size_t stride ) const
18174  {
18176  "Function <vkWriteAccelerationStructuresPropertiesKHR> requires <VK_KHR_acceleration_structure>" );
18177 
18178  VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
18179  std::vector<DataType> data( dataSize / sizeof( DataType ) );
18181  getDispatcher()->vkWriteAccelerationStructuresPropertiesKHR( static_cast<VkDevice>( m_device ),
18182  accelerationStructures.size(),
18183  reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ),
18184  static_cast<VkQueryType>( queryType ),
18185  data.size() * sizeof( DataType ),
18186  reinterpret_cast<void *>( data.data() ),
18187  stride ) );
18188  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertiesKHR" );
18189 
18190  return data;
18191  }
18192 
18193  template <typename DataType>
18194  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DataType Device::writeAccelerationStructuresPropertyKHR(
18195  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
18197  size_t stride ) const
18198  {
18200  "Function <vkWriteAccelerationStructuresPropertiesKHR> requires <VK_KHR_acceleration_structure>" );
18201 
18202  DataType data;
18204  getDispatcher()->vkWriteAccelerationStructuresPropertiesKHR( static_cast<VkDevice>( m_device ),
18205  accelerationStructures.size(),
18206  reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ),
18207  static_cast<VkQueryType>( queryType ),
18208  sizeof( DataType ),
18209  reinterpret_cast<void *>( &data ),
18210  stride ) );
18211  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertyKHR" );
18212 
18213  return data;
18214  }
18215 
18216  VULKAN_HPP_INLINE void
18217  CommandBuffer::copyAccelerationStructureKHR( const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR & info ) const VULKAN_HPP_NOEXCEPT
18218  {
18220  "Function <vkCmdCopyAccelerationStructureKHR> requires <VK_KHR_acceleration_structure>" );
18221 
18222  getDispatcher()->vkCmdCopyAccelerationStructureKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
18223  reinterpret_cast<const VkCopyAccelerationStructureInfoKHR *>( &info ) );
18224  }
18225 
18226  VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureToMemoryKHR(
18227  const VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR & info ) const VULKAN_HPP_NOEXCEPT
18228  {
18230  "Function <vkCmdCopyAccelerationStructureToMemoryKHR> requires <VK_KHR_acceleration_structure>" );
18231 
18232  getDispatcher()->vkCmdCopyAccelerationStructureToMemoryKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
18233  reinterpret_cast<const VkCopyAccelerationStructureToMemoryInfoKHR *>( &info ) );
18234  }
18235 
18236  VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToAccelerationStructureKHR(
18237  const VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR & info ) const VULKAN_HPP_NOEXCEPT
18238  {
18240  "Function <vkCmdCopyMemoryToAccelerationStructureKHR> requires <VK_KHR_acceleration_structure>" );
18241 
18242  getDispatcher()->vkCmdCopyMemoryToAccelerationStructureKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
18243  reinterpret_cast<const VkCopyMemoryToAccelerationStructureInfoKHR *>( &info ) );
18244  }
18245 
18247  Device::getAccelerationStructureAddressKHR( const VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR & info ) const VULKAN_HPP_NOEXCEPT
18248  {
18250  "Function <vkGetAccelerationStructureDeviceAddressKHR> requires <VK_KHR_acceleration_structure>" );
18251 
18252  VkDeviceAddress result = getDispatcher()->vkGetAccelerationStructureDeviceAddressKHR(
18253  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkAccelerationStructureDeviceAddressInfoKHR *>( &info ) );
18254 
18255  return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>( result );
18256  }
18257 
18258  VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesKHR(
18259  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR> const & accelerationStructures,
18261  VULKAN_HPP_NAMESPACE::QueryPool queryPool,
18262  uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT
18263  {
18265  "Function <vkCmdWriteAccelerationStructuresPropertiesKHR> requires <VK_KHR_acceleration_structure>" );
18266 
18267  getDispatcher()->vkCmdWriteAccelerationStructuresPropertiesKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
18268  accelerationStructures.size(),
18269  reinterpret_cast<const VkAccelerationStructureKHR *>( accelerationStructures.data() ),
18270  static_cast<VkQueryType>( queryType ),
18271  static_cast<VkQueryPool>( queryPool ),
18272  firstQuery );
18273  }
18274 
18276  const VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR & versionInfo ) const VULKAN_HPP_NOEXCEPT
18277  {
18279  "Function <vkGetDeviceAccelerationStructureCompatibilityKHR> requires <VK_KHR_acceleration_structure>" );
18280 
18282  getDispatcher()->vkGetDeviceAccelerationStructureCompatibilityKHR( static_cast<VkDevice>( m_device ),
18283  reinterpret_cast<const VkAccelerationStructureVersionInfoKHR *>( &versionInfo ),
18284  reinterpret_cast<VkAccelerationStructureCompatibilityKHR *>( &compatibility ) );
18285 
18286  return compatibility;
18287  }
18288 
18289  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR
18290  Device::getAccelerationStructureBuildSizesKHR( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType,
18291  const VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR & buildInfo,
18292  VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & maxPrimitiveCounts ) const
18293  {
18295  "Function <vkGetAccelerationStructureBuildSizesKHR> requires <VK_KHR_acceleration_structure>" );
18296 # ifdef VULKAN_HPP_NO_EXCEPTIONS
18297  VULKAN_HPP_ASSERT( maxPrimitiveCounts.size() == buildInfo.geometryCount );
18298 # else
18299  if ( maxPrimitiveCounts.size() != buildInfo.geometryCount )
18300  {
18301  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureBuildSizesKHR: maxPrimitiveCounts.size() != buildInfo.geometryCount" );
18302  }
18303 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
18304 
18305  VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR sizeInfo;
18306  getDispatcher()->vkGetAccelerationStructureBuildSizesKHR( static_cast<VkDevice>( m_device ),
18307  static_cast<VkAccelerationStructureBuildTypeKHR>( buildType ),
18308  reinterpret_cast<const VkAccelerationStructureBuildGeometryInfoKHR *>( &buildInfo ),
18309  maxPrimitiveCounts.data(),
18310  reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR *>( &sizeInfo ) );
18311 
18312  return sizeInfo;
18313  }
18314 
18315  //=== VK_KHR_ray_tracing_pipeline ===
18316 
18317  VULKAN_HPP_INLINE void CommandBuffer::traceRaysKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
18318  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable,
18319  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable,
18320  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable,
18321  uint32_t width,
18322  uint32_t height,
18323  uint32_t depth ) const VULKAN_HPP_NOEXCEPT
18324  {
18325  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdTraceRaysKHR && "Function <vkCmdTraceRaysKHR> requires <VK_KHR_ray_tracing_pipeline>" );
18326 
18327  getDispatcher()->vkCmdTraceRaysKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
18328  reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &raygenShaderBindingTable ),
18329  reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &missShaderBindingTable ),
18330  reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &hitShaderBindingTable ),
18331  reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &callableShaderBindingTable ),
18332  width,
18333  height,
18334  depth );
18335  }
18336 
18338  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>>::Type
18339  Device::createRayTracingPipelinesKHR(
18340  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR> const & deferredOperation,
18341  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,
18342  VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR> const & createInfos,
18343  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
18344  {
18345  std::vector<VULKAN_HPP_NAMESPACE::Pipeline> pipelines( createInfos.size() );
18346  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateRayTracingPipelinesKHR(
18347  static_cast<VkDevice>( m_device ),
18348  deferredOperation ? static_cast<VkDeferredOperationKHR>( **deferredOperation ) : 0,
18349  pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0,
18350  createInfos.size(),
18351  reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>( createInfos.data() ),
18352  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
18353  reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
18354  if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( result != VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR ) &&
18355  ( result != VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR ) && ( result != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) )
18356  {
18357 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
18358  return VULKAN_HPP_UNEXPECTED( result );
18359 # else
18360  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createRayTracingPipelinesKHR" );
18361 # endif
18362  }
18363 
18364  std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline> pipelinesRAII;
18365  pipelinesRAII.reserve( pipelines.size() );
18366  for ( auto & pipeline : pipelines )
18367  {
18368  pipelinesRAII.emplace_back( *this, *reinterpret_cast<VkPipeline *>( &pipeline ), allocator, result );
18369  }
18370  return pipelinesRAII;
18371  }
18372 
18374  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>::Type
18375  Device::createRayTracingPipelineKHR(
18376  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR> const & deferredOperation,
18377  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,
18378  VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR const & createInfo,
18379  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT
18380  {
18381  VULKAN_HPP_NAMESPACE::Pipeline pipeline;
18382  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateRayTracingPipelinesKHR(
18383  static_cast<VkDevice>( m_device ),
18384  deferredOperation ? static_cast<VkDeferredOperationKHR>( **deferredOperation ) : 0,
18385  pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0,
18386  1,
18387  reinterpret_cast<const VkRayTracingPipelineCreateInfoKHR *>( &createInfo ),
18388  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
18389  reinterpret_cast<VkPipeline *>( &pipeline ) ) );
18390  if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( result != VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR ) &&
18391  ( result != VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR ) && ( result != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) )
18392  {
18393 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
18394  return VULKAN_HPP_UNEXPECTED( result );
18395 # else
18396  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createRayTracingPipelineKHR" );
18397 # endif
18398  }
18399 
18400  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline( *this, *reinterpret_cast<VkPipeline *>( &pipeline ), allocator );
18401  }
18402 
18403  template <typename DataType>
18404  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<DataType>
18405  Pipeline::getRayTracingShaderGroupHandlesKHR( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const
18406  {
18408  "Function <vkGetRayTracingShaderGroupHandlesKHR> requires <VK_KHR_ray_tracing_pipeline> or <VK_NV_ray_tracing>" );
18409 
18410  VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
18411  std::vector<DataType> data( dataSize / sizeof( DataType ) );
18413  static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR( static_cast<VkDevice>( m_device ),
18414  static_cast<VkPipeline>( m_pipeline ),
18415  firstGroup,
18416  groupCount,
18417  data.size() * sizeof( DataType ),
18418  reinterpret_cast<void *>( data.data() ) ) );
18419  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingShaderGroupHandlesKHR" );
18420 
18421  return data;
18422  }
18423 
18424  template <typename DataType>
18425  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DataType Pipeline::getRayTracingShaderGroupHandleKHR( uint32_t firstGroup, uint32_t groupCount ) const
18426  {
18428  "Function <vkGetRayTracingShaderGroupHandlesKHR> requires <VK_KHR_ray_tracing_pipeline> or <VK_NV_ray_tracing>" );
18429 
18430  DataType data;
18432  static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR( static_cast<VkDevice>( m_device ),
18433  static_cast<VkPipeline>( m_pipeline ),
18434  firstGroup,
18435  groupCount,
18436  sizeof( DataType ),
18437  reinterpret_cast<void *>( &data ) ) );
18438  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingShaderGroupHandleKHR" );
18439 
18440  return data;
18441  }
18442 
18443  template <typename DataType>
18444  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<DataType>
18445  Pipeline::getRayTracingCaptureReplayShaderGroupHandlesKHR( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const
18446  {
18448  "Function <vkGetRayTracingCaptureReplayShaderGroupHandlesKHR> requires <VK_KHR_ray_tracing_pipeline>" );
18449 
18450  VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
18451  std::vector<DataType> data( dataSize / sizeof( DataType ) );
18453  getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( static_cast<VkDevice>( m_device ),
18454  static_cast<VkPipeline>( m_pipeline ),
18455  firstGroup,
18456  groupCount,
18457  data.size() * sizeof( DataType ),
18458  reinterpret_cast<void *>( data.data() ) ) );
18459  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingCaptureReplayShaderGroupHandlesKHR" );
18460 
18461  return data;
18462  }
18463 
18464  template <typename DataType>
18465  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DataType Pipeline::getRayTracingCaptureReplayShaderGroupHandleKHR( uint32_t firstGroup, uint32_t groupCount ) const
18466  {
18468  "Function <vkGetRayTracingCaptureReplayShaderGroupHandlesKHR> requires <VK_KHR_ray_tracing_pipeline>" );
18469 
18470  DataType data;
18472  static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( static_cast<VkDevice>( m_device ),
18473  static_cast<VkPipeline>( m_pipeline ),
18474  firstGroup,
18475  groupCount,
18476  sizeof( DataType ),
18477  reinterpret_cast<void *>( &data ) ) );
18478  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingCaptureReplayShaderGroupHandleKHR" );
18479 
18480  return data;
18481  }
18482 
18483  VULKAN_HPP_INLINE void CommandBuffer::traceRaysIndirectKHR( const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & raygenShaderBindingTable,
18484  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & missShaderBindingTable,
18485  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & hitShaderBindingTable,
18486  const VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR & callableShaderBindingTable,
18487  VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT
18488  {
18489  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdTraceRaysIndirectKHR && "Function <vkCmdTraceRaysIndirectKHR> requires <VK_KHR_ray_tracing_pipeline>" );
18490 
18491  getDispatcher()->vkCmdTraceRaysIndirectKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
18492  reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &raygenShaderBindingTable ),
18493  reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &missShaderBindingTable ),
18494  reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &hitShaderBindingTable ),
18495  reinterpret_cast<const VkStridedDeviceAddressRegionKHR *>( &callableShaderBindingTable ),
18496  static_cast<VkDeviceAddress>( indirectDeviceAddress ) );
18497  }
18498 
18500  Pipeline::getRayTracingShaderGroupStackSizeKHR( uint32_t group, VULKAN_HPP_NAMESPACE::ShaderGroupShaderKHR groupShader ) const VULKAN_HPP_NOEXCEPT
18501  {
18503  "Function <vkGetRayTracingShaderGroupStackSizeKHR> requires <VK_KHR_ray_tracing_pipeline>" );
18504 
18505  VkDeviceSize result = getDispatcher()->vkGetRayTracingShaderGroupStackSizeKHR(
18506  static_cast<VkDevice>( m_device ), static_cast<VkPipeline>( m_pipeline ), group, static_cast<VkShaderGroupShaderKHR>( groupShader ) );
18507 
18508  return static_cast<VULKAN_HPP_NAMESPACE::DeviceSize>( result );
18509  }
18510 
18511  VULKAN_HPP_INLINE void CommandBuffer::setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize ) const VULKAN_HPP_NOEXCEPT
18512  {
18514  "Function <vkCmdSetRayTracingPipelineStackSizeKHR> requires <VK_KHR_ray_tracing_pipeline>" );
18515 
18516  getDispatcher()->vkCmdSetRayTracingPipelineStackSizeKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), pipelineStackSize );
18517  }
18518 
18519  //=== VK_KHR_sampler_ycbcr_conversion ===
18520 
18522  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion>::Type
18523  Device::createSamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & createInfo,
18524  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
18526  {
18527  VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion;
18528  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateSamplerYcbcrConversionKHR(
18529  static_cast<VkDevice>( m_device ),
18530  reinterpret_cast<const VkSamplerYcbcrConversionCreateInfo *>( &createInfo ),
18531  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
18532  reinterpret_cast<VkSamplerYcbcrConversion *>( &ycbcrConversion ) ) );
18533  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
18534  {
18535 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
18536  return VULKAN_HPP_UNEXPECTED( result );
18537 # else
18538  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createSamplerYcbcrConversionKHR" );
18539 # endif
18540  }
18541 
18542  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion(
18543  *this, *reinterpret_cast<VkSamplerYcbcrConversion *>( &ycbcrConversion ), allocator );
18544  }
18545 
18546  VULKAN_HPP_INLINE void
18547  Device::destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion,
18549  {
18551  "Function <vkDestroySamplerYcbcrConversionKHR> requires <VK_KHR_sampler_ycbcr_conversion> or <VK_VERSION_1_1>" );
18552 
18553  getDispatcher()->vkDestroySamplerYcbcrConversionKHR(
18554  static_cast<VkDevice>( m_device ),
18555  static_cast<VkSamplerYcbcrConversion>( ycbcrConversion ),
18556  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
18557  }
18558 
18559  //=== VK_KHR_bind_memory2 ===
18560 
18561  VULKAN_HPP_INLINE void
18562  Device::bindBufferMemory2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo> const & bindInfos ) const
18563  {
18564  VULKAN_HPP_ASSERT( getDispatcher()->vkBindBufferMemory2KHR && "Function <vkBindBufferMemory2KHR> requires <VK_KHR_bind_memory2> or <VK_VERSION_1_1>" );
18565 
18566  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkBindBufferMemory2KHR(
18567  static_cast<VkDevice>( m_device ), bindInfos.size(), reinterpret_cast<const VkBindBufferMemoryInfo *>( bindInfos.data() ) ) );
18568  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory2KHR" );
18569  }
18570 
18571  VULKAN_HPP_INLINE void
18572  Device::bindImageMemory2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindImageMemoryInfo> const & bindInfos ) const
18573  {
18574  VULKAN_HPP_ASSERT( getDispatcher()->vkBindImageMemory2KHR && "Function <vkBindImageMemory2KHR> requires <VK_KHR_bind_memory2> or <VK_VERSION_1_1>" );
18575 
18576  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkBindImageMemory2KHR(
18577  static_cast<VkDevice>( m_device ), bindInfos.size(), reinterpret_cast<const VkBindImageMemoryInfo *>( bindInfos.data() ) ) );
18578  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory2KHR" );
18579  }
18580 
18581  //=== VK_EXT_image_drm_format_modifier ===
18582 
18583  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT Image::getDrmFormatModifierPropertiesEXT() const
18584  {
18586  "Function <vkGetImageDrmFormatModifierPropertiesEXT> requires <VK_EXT_image_drm_format_modifier>" );
18587 
18588  VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT properties;
18589  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetImageDrmFormatModifierPropertiesEXT(
18590  static_cast<VkDevice>( m_device ), static_cast<VkImage>( m_image ), reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT *>( &properties ) ) );
18591  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Image::getDrmFormatModifierPropertiesEXT" );
18592 
18593  return properties;
18594  }
18595 
18596  //=== VK_EXT_validation_cache ===
18597 
18599  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ValidationCacheEXT>::Type
18600  Device::createValidationCacheEXT( VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT const & createInfo,
18601  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
18603  {
18604  VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache;
18605  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateValidationCacheEXT(
18606  static_cast<VkDevice>( m_device ),
18607  reinterpret_cast<const VkValidationCacheCreateInfoEXT *>( &createInfo ),
18608  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
18609  reinterpret_cast<VkValidationCacheEXT *>( &validationCache ) ) );
18610  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
18611  {
18612 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
18613  return VULKAN_HPP_UNEXPECTED( result );
18614 # else
18615  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createValidationCacheEXT" );
18616 # endif
18617  }
18618 
18619  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ValidationCacheEXT(
18620  *this, *reinterpret_cast<VkValidationCacheEXT *>( &validationCache ), allocator );
18621  }
18622 
18623  VULKAN_HPP_INLINE void ValidationCacheEXT::merge( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ValidationCacheEXT> const & srcCaches ) const
18624  {
18625  VULKAN_HPP_ASSERT( getDispatcher()->vkMergeValidationCachesEXT && "Function <vkMergeValidationCachesEXT> requires <VK_EXT_validation_cache>" );
18626 
18628  getDispatcher()->vkMergeValidationCachesEXT( static_cast<VkDevice>( m_device ),
18629  static_cast<VkValidationCacheEXT>( m_validationCache ),
18630  srcCaches.size(),
18631  reinterpret_cast<const VkValidationCacheEXT *>( srcCaches.data() ) ) );
18632  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::ValidationCacheEXT::merge" );
18633  }
18634 
18635  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<uint8_t> ValidationCacheEXT::getData() const
18636  {
18637  VULKAN_HPP_ASSERT( getDispatcher()->vkGetValidationCacheDataEXT && "Function <vkGetValidationCacheDataEXT> requires <VK_EXT_validation_cache>" );
18638 
18639  std::vector<uint8_t> data;
18640  size_t dataSize;
18642  do
18643  {
18644  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetValidationCacheDataEXT(
18645  static_cast<VkDevice>( m_device ), static_cast<VkValidationCacheEXT>( m_validationCache ), &dataSize, nullptr ) );
18646  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && dataSize )
18647  {
18648  data.resize( dataSize );
18649  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetValidationCacheDataEXT(
18650  static_cast<VkDevice>( m_device ), static_cast<VkValidationCacheEXT>( m_validationCache ), &dataSize, reinterpret_cast<void *>( data.data() ) ) );
18651  }
18652  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
18653  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::ValidationCacheEXT::getData" );
18654  VULKAN_HPP_ASSERT( dataSize <= data.size() );
18655  if ( dataSize < data.size() )
18656  {
18657  data.resize( dataSize );
18658  }
18659  return data;
18660  }
18661 
18662  //=== VK_NV_shading_rate_image ===
18663 
18664  VULKAN_HPP_INLINE void CommandBuffer::bindShadingRateImageNV( VULKAN_HPP_NAMESPACE::ImageView imageView,
18666  {
18667  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindShadingRateImageNV && "Function <vkCmdBindShadingRateImageNV> requires <VK_NV_shading_rate_image>" );
18668 
18669  getDispatcher()->vkCmdBindShadingRateImageNV(
18670  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkImageView>( imageView ), static_cast<VkImageLayout>( imageLayout ) );
18671  }
18672 
18673  VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV(
18674  uint32_t firstViewport,
18675  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV> const & shadingRatePalettes ) const VULKAN_HPP_NOEXCEPT
18676  {
18678  "Function <vkCmdSetViewportShadingRatePaletteNV> requires <VK_NV_shading_rate_image>" );
18679 
18680  getDispatcher()->vkCmdSetViewportShadingRatePaletteNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
18681  firstViewport,
18682  shadingRatePalettes.size(),
18683  reinterpret_cast<const VkShadingRatePaletteNV *>( shadingRatePalettes.data() ) );
18684  }
18685 
18686  VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV(
18688  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV> const & customSampleOrders ) const VULKAN_HPP_NOEXCEPT
18689  {
18690  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCoarseSampleOrderNV && "Function <vkCmdSetCoarseSampleOrderNV> requires <VK_NV_shading_rate_image>" );
18691 
18692  getDispatcher()->vkCmdSetCoarseSampleOrderNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
18693  static_cast<VkCoarseSampleOrderTypeNV>( sampleOrderType ),
18694  customSampleOrders.size(),
18695  reinterpret_cast<const VkCoarseSampleOrderCustomNV *>( customSampleOrders.data() ) );
18696  }
18697 
18698  //=== VK_NV_ray_tracing ===
18699 
18701  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureNV>::Type
18702  Device::createAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV const & createInfo,
18703  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
18705  {
18706  VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure;
18707  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateAccelerationStructureNV(
18708  static_cast<VkDevice>( m_device ),
18709  reinterpret_cast<const VkAccelerationStructureCreateInfoNV *>( &createInfo ),
18710  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
18711  reinterpret_cast<VkAccelerationStructureNV *>( &accelerationStructure ) ) );
18712  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
18713  {
18714 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
18715  return VULKAN_HPP_UNEXPECTED( result );
18716 # else
18717  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createAccelerationStructureNV" );
18718 # endif
18719  }
18720 
18721  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureNV(
18722  *this, *reinterpret_cast<VkAccelerationStructureNV *>( &accelerationStructure ), allocator );
18723  }
18724 
18725  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR Device::getAccelerationStructureMemoryRequirementsNV(
18726  const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT
18727  {
18729  "Function <vkGetAccelerationStructureMemoryRequirementsNV> requires <VK_NV_ray_tracing>" );
18730 
18732  getDispatcher()->vkGetAccelerationStructureMemoryRequirementsNV( static_cast<VkDevice>( m_device ),
18733  reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV *>( &info ),
18734  reinterpret_cast<VkMemoryRequirements2KHR *>( &memoryRequirements ) );
18735 
18736  return memoryRequirements;
18737  }
18738 
18739  template <typename X, typename Y, typename... Z>
18740  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> Device::getAccelerationStructureMemoryRequirementsNV(
18741  const VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT
18742  {
18744  "Function <vkGetAccelerationStructureMemoryRequirementsNV> requires <VK_NV_ray_tracing>" );
18745 
18746  VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
18747  VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2KHR>();
18748  getDispatcher()->vkGetAccelerationStructureMemoryRequirementsNV( static_cast<VkDevice>( m_device ),
18749  reinterpret_cast<const VkAccelerationStructureMemoryRequirementsInfoNV *>( &info ),
18750  reinterpret_cast<VkMemoryRequirements2KHR *>( &memoryRequirements ) );
18751 
18752  return structureChain;
18753  }
18754 
18755  VULKAN_HPP_INLINE void Device::bindAccelerationStructureMemoryNV(
18756  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV> const & bindInfos ) const
18757  {
18759  "Function <vkBindAccelerationStructureMemoryNV> requires <VK_NV_ray_tracing>" );
18760 
18761  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkBindAccelerationStructureMemoryNV(
18762  static_cast<VkDevice>( m_device ), bindInfos.size(), reinterpret_cast<const VkBindAccelerationStructureMemoryInfoNV *>( bindInfos.data() ) ) );
18763  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindAccelerationStructureMemoryNV" );
18764  }
18765 
18766  VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV( const VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV & info,
18767  VULKAN_HPP_NAMESPACE::Buffer instanceData,
18768  VULKAN_HPP_NAMESPACE::DeviceSize instanceOffset,
18770  VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst,
18771  VULKAN_HPP_NAMESPACE::AccelerationStructureNV src,
18772  VULKAN_HPP_NAMESPACE::Buffer scratch,
18774  {
18775  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBuildAccelerationStructureNV && "Function <vkCmdBuildAccelerationStructureNV> requires <VK_NV_ray_tracing>" );
18776 
18777  getDispatcher()->vkCmdBuildAccelerationStructureNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
18778  reinterpret_cast<const VkAccelerationStructureInfoNV *>( &info ),
18779  static_cast<VkBuffer>( instanceData ),
18780  static_cast<VkDeviceSize>( instanceOffset ),
18781  static_cast<VkBool32>( update ),
18782  static_cast<VkAccelerationStructureNV>( dst ),
18783  static_cast<VkAccelerationStructureNV>( src ),
18784  static_cast<VkBuffer>( scratch ),
18785  static_cast<VkDeviceSize>( scratchOffset ) );
18786  }
18787 
18788  VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst,
18789  VULKAN_HPP_NAMESPACE::AccelerationStructureNV src,
18791  {
18792  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyAccelerationStructureNV && "Function <vkCmdCopyAccelerationStructureNV> requires <VK_NV_ray_tracing>" );
18793 
18794  getDispatcher()->vkCmdCopyAccelerationStructureNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
18795  static_cast<VkAccelerationStructureNV>( dst ),
18796  static_cast<VkAccelerationStructureNV>( src ),
18797  static_cast<VkCopyAccelerationStructureModeKHR>( mode ) );
18798  }
18799 
18800  VULKAN_HPP_INLINE void CommandBuffer::traceRaysNV( VULKAN_HPP_NAMESPACE::Buffer raygenShaderBindingTableBuffer,
18801  VULKAN_HPP_NAMESPACE::DeviceSize raygenShaderBindingOffset,
18802  VULKAN_HPP_NAMESPACE::Buffer missShaderBindingTableBuffer,
18803  VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingOffset,
18804  VULKAN_HPP_NAMESPACE::DeviceSize missShaderBindingStride,
18805  VULKAN_HPP_NAMESPACE::Buffer hitShaderBindingTableBuffer,
18806  VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingOffset,
18807  VULKAN_HPP_NAMESPACE::DeviceSize hitShaderBindingStride,
18808  VULKAN_HPP_NAMESPACE::Buffer callableShaderBindingTableBuffer,
18809  VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingOffset,
18810  VULKAN_HPP_NAMESPACE::DeviceSize callableShaderBindingStride,
18811  uint32_t width,
18812  uint32_t height,
18813  uint32_t depth ) const VULKAN_HPP_NOEXCEPT
18814  {
18815  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdTraceRaysNV && "Function <vkCmdTraceRaysNV> requires <VK_NV_ray_tracing>" );
18816 
18817  getDispatcher()->vkCmdTraceRaysNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
18818  static_cast<VkBuffer>( raygenShaderBindingTableBuffer ),
18819  static_cast<VkDeviceSize>( raygenShaderBindingOffset ),
18820  static_cast<VkBuffer>( missShaderBindingTableBuffer ),
18821  static_cast<VkDeviceSize>( missShaderBindingOffset ),
18822  static_cast<VkDeviceSize>( missShaderBindingStride ),
18823  static_cast<VkBuffer>( hitShaderBindingTableBuffer ),
18824  static_cast<VkDeviceSize>( hitShaderBindingOffset ),
18825  static_cast<VkDeviceSize>( hitShaderBindingStride ),
18826  static_cast<VkBuffer>( callableShaderBindingTableBuffer ),
18827  static_cast<VkDeviceSize>( callableShaderBindingOffset ),
18828  static_cast<VkDeviceSize>( callableShaderBindingStride ),
18829  width,
18830  height,
18831  depth );
18832  }
18833 
18835  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>>::Type
18836  Device::createRayTracingPipelinesNV(
18837  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,
18838  VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV> const & createInfos,
18839  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
18840  {
18841  std::vector<VULKAN_HPP_NAMESPACE::Pipeline> pipelines( createInfos.size() );
18842  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateRayTracingPipelinesNV(
18843  static_cast<VkDevice>( m_device ),
18844  pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0,
18845  createInfos.size(),
18846  reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( createInfos.data() ),
18847  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
18848  reinterpret_cast<VkPipeline *>( pipelines.data() ) ) );
18849  if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( result != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) )
18850  {
18851 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
18852  return VULKAN_HPP_UNEXPECTED( result );
18853 # else
18854  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createRayTracingPipelinesNV" );
18855 # endif
18856  }
18857 
18858  std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline> pipelinesRAII;
18859  pipelinesRAII.reserve( pipelines.size() );
18860  for ( auto & pipeline : pipelines )
18861  {
18862  pipelinesRAII.emplace_back( *this, *reinterpret_cast<VkPipeline *>( &pipeline ), allocator, result );
18863  }
18864  return pipelinesRAII;
18865  }
18866 
18868  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline>::Type
18869  Device::createRayTracingPipelineNV(
18870  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineCache> const & pipelineCache,
18871  VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV const & createInfo,
18872  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT
18873  {
18874  VULKAN_HPP_NAMESPACE::Pipeline pipeline;
18875  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateRayTracingPipelinesNV(
18876  static_cast<VkDevice>( m_device ),
18877  pipelineCache ? static_cast<VkPipelineCache>( **pipelineCache ) : 0,
18878  1,
18879  reinterpret_cast<const VkRayTracingPipelineCreateInfoNV *>( &createInfo ),
18880  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
18881  reinterpret_cast<VkPipeline *>( &pipeline ) ) );
18882  if ( ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) && ( result != VULKAN_HPP_NAMESPACE::Result::ePipelineCompileRequiredEXT ) )
18883  {
18884 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
18885  return VULKAN_HPP_UNEXPECTED( result );
18886 # else
18887  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createRayTracingPipelineNV" );
18888 # endif
18889  }
18890 
18891  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Pipeline( *this, *reinterpret_cast<VkPipeline *>( &pipeline ), allocator );
18892  }
18893 
18894  template <typename DataType>
18895  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<DataType>
18896  Pipeline::getRayTracingShaderGroupHandlesNV( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const
18897  {
18899  "Function <vkGetRayTracingShaderGroupHandlesNV> requires <VK_KHR_ray_tracing_pipeline> or <VK_NV_ray_tracing>" );
18900 
18901  VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
18902  std::vector<DataType> data( dataSize / sizeof( DataType ) );
18904  static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetRayTracingShaderGroupHandlesNV( static_cast<VkDevice>( m_device ),
18905  static_cast<VkPipeline>( m_pipeline ),
18906  firstGroup,
18907  groupCount,
18908  data.size() * sizeof( DataType ),
18909  reinterpret_cast<void *>( data.data() ) ) );
18910  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingShaderGroupHandlesNV" );
18911 
18912  return data;
18913  }
18914 
18915  template <typename DataType>
18916  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DataType Pipeline::getRayTracingShaderGroupHandleNV( uint32_t firstGroup, uint32_t groupCount ) const
18917  {
18919  "Function <vkGetRayTracingShaderGroupHandlesNV> requires <VK_KHR_ray_tracing_pipeline> or <VK_NV_ray_tracing>" );
18920 
18921  DataType data;
18923  static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetRayTracingShaderGroupHandlesNV( static_cast<VkDevice>( m_device ),
18924  static_cast<VkPipeline>( m_pipeline ),
18925  firstGroup,
18926  groupCount,
18927  sizeof( DataType ),
18928  reinterpret_cast<void *>( &data ) ) );
18929  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::getRayTracingShaderGroupHandleNV" );
18930 
18931  return data;
18932  }
18933 
18934  template <typename DataType>
18935  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<DataType> AccelerationStructureNV::getHandle( size_t dataSize ) const
18936  {
18937  VULKAN_HPP_ASSERT( getDispatcher()->vkGetAccelerationStructureHandleNV && "Function <vkGetAccelerationStructureHandleNV> requires <VK_NV_ray_tracing>" );
18938 
18939  VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
18940  std::vector<DataType> data( dataSize / sizeof( DataType ) );
18942  getDispatcher()->vkGetAccelerationStructureHandleNV( static_cast<VkDevice>( m_device ),
18943  static_cast<VkAccelerationStructureNV>( m_accelerationStructure ),
18944  data.size() * sizeof( DataType ),
18945  reinterpret_cast<void *>( data.data() ) ) );
18946  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::AccelerationStructureNV::getHandle" );
18947 
18948  return data;
18949  }
18950 
18951  template <typename DataType>
18952  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DataType AccelerationStructureNV::getHandle() const
18953  {
18954  VULKAN_HPP_ASSERT( getDispatcher()->vkGetAccelerationStructureHandleNV && "Function <vkGetAccelerationStructureHandleNV> requires <VK_NV_ray_tracing>" );
18955 
18956  DataType data;
18958  getDispatcher()->vkGetAccelerationStructureHandleNV( static_cast<VkDevice>( m_device ),
18959  static_cast<VkAccelerationStructureNV>( m_accelerationStructure ),
18960  sizeof( DataType ),
18961  reinterpret_cast<void *>( &data ) ) );
18962  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::AccelerationStructureNV::getHandle" );
18963 
18964  return data;
18965  }
18966 
18967  VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV(
18968  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::AccelerationStructureNV> const & accelerationStructures,
18970  VULKAN_HPP_NAMESPACE::QueryPool queryPool,
18971  uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT
18972  {
18974  "Function <vkCmdWriteAccelerationStructuresPropertiesNV> requires <VK_NV_ray_tracing>" );
18975 
18976  getDispatcher()->vkCmdWriteAccelerationStructuresPropertiesNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
18977  accelerationStructures.size(),
18978  reinterpret_cast<const VkAccelerationStructureNV *>( accelerationStructures.data() ),
18979  static_cast<VkQueryType>( queryType ),
18980  static_cast<VkQueryPool>( queryPool ),
18981  firstQuery );
18982  }
18983 
18984  VULKAN_HPP_INLINE void Pipeline::compileDeferredNV( uint32_t shader ) const
18985  {
18986  VULKAN_HPP_ASSERT( getDispatcher()->vkCompileDeferredNV && "Function <vkCompileDeferredNV> requires <VK_NV_ray_tracing>" );
18987 
18989  getDispatcher()->vkCompileDeferredNV( static_cast<VkDevice>( m_device ), static_cast<VkPipeline>( m_pipeline ), shader ) );
18990  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Pipeline::compileDeferredNV" );
18991  }
18992 
18993  //=== VK_KHR_maintenance3 ===
18994 
18995  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport
18996  Device::getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT
18997  {
18999  "Function <vkGetDescriptorSetLayoutSupportKHR> requires <VK_KHR_maintenance3> or <VK_VERSION_1_1>" );
19000 
19001  VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport support;
19002  getDispatcher()->vkGetDescriptorSetLayoutSupportKHR( static_cast<VkDevice>( m_device ),
19003  reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
19004  reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) );
19005 
19006  return support;
19007  }
19008 
19009  template <typename X, typename Y, typename... Z>
19010  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
19011  Device::getDescriptorSetLayoutSupportKHR( const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT
19012  {
19014  "Function <vkGetDescriptorSetLayoutSupportKHR> requires <VK_KHR_maintenance3> or <VK_VERSION_1_1>" );
19015 
19016  VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
19017  VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport & support = structureChain.template get<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport>();
19018  getDispatcher()->vkGetDescriptorSetLayoutSupportKHR( static_cast<VkDevice>( m_device ),
19019  reinterpret_cast<const VkDescriptorSetLayoutCreateInfo *>( &createInfo ),
19020  reinterpret_cast<VkDescriptorSetLayoutSupport *>( &support ) );
19021 
19022  return structureChain;
19023  }
19024 
19025  //=== VK_KHR_draw_indirect_count ===
19026 
19027  VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer,
19029  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
19030  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
19031  uint32_t maxDrawCount,
19032  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
19033  {
19034  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndirectCountKHR &&
19035  "Function <vkCmdDrawIndirectCountKHR> requires <VK_AMD_draw_indirect_count> or <VK_KHR_draw_indirect_count> or <VK_VERSION_1_2>" );
19036 
19037  getDispatcher()->vkCmdDrawIndirectCountKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
19038  static_cast<VkBuffer>( buffer ),
19039  static_cast<VkDeviceSize>( offset ),
19040  static_cast<VkBuffer>( countBuffer ),
19041  static_cast<VkDeviceSize>( countBufferOffset ),
19042  maxDrawCount,
19043  stride );
19044  }
19045 
19046  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer,
19048  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
19049  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
19050  uint32_t maxDrawCount,
19051  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
19052  {
19054  getDispatcher()->vkCmdDrawIndexedIndirectCountKHR &&
19055  "Function <vkCmdDrawIndexedIndirectCountKHR> requires <VK_AMD_draw_indirect_count> or <VK_KHR_draw_indirect_count> or <VK_VERSION_1_2>" );
19056 
19057  getDispatcher()->vkCmdDrawIndexedIndirectCountKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
19058  static_cast<VkBuffer>( buffer ),
19059  static_cast<VkDeviceSize>( offset ),
19060  static_cast<VkBuffer>( countBuffer ),
19061  static_cast<VkDeviceSize>( countBufferOffset ),
19062  maxDrawCount,
19063  stride );
19064  }
19065 
19066  //=== VK_EXT_external_memory_host ===
19067 
19068  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT
19069  Device::getMemoryHostPointerPropertiesEXT( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, const void * pHostPointer ) const
19070  {
19072  "Function <vkGetMemoryHostPointerPropertiesEXT> requires <VK_EXT_external_memory_host>" );
19073 
19074  VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT memoryHostPointerProperties;
19076  getDispatcher()->vkGetMemoryHostPointerPropertiesEXT( static_cast<VkDevice>( m_device ),
19077  static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
19078  pHostPointer,
19079  reinterpret_cast<VkMemoryHostPointerPropertiesEXT *>( &memoryHostPointerProperties ) ) );
19080  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryHostPointerPropertiesEXT" );
19081 
19082  return memoryHostPointerProperties;
19083  }
19084 
19085  //=== VK_AMD_buffer_marker ===
19086 
19087  VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarkerAMD( VULKAN_HPP_NAMESPACE::PipelineStageFlagBits pipelineStage,
19088  VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
19090  uint32_t marker ) const VULKAN_HPP_NOEXCEPT
19091  {
19092  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteBufferMarkerAMD && "Function <vkCmdWriteBufferMarkerAMD> requires <VK_AMD_buffer_marker>" );
19093 
19094  getDispatcher()->vkCmdWriteBufferMarkerAMD( static_cast<VkCommandBuffer>( m_commandBuffer ),
19095  static_cast<VkPipelineStageFlagBits>( pipelineStage ),
19096  static_cast<VkBuffer>( dstBuffer ),
19097  static_cast<VkDeviceSize>( dstOffset ),
19098  marker );
19099  }
19100 
19101  //=== VK_EXT_calibrated_timestamps ===
19102 
19103  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR> PhysicalDevice::getCalibrateableTimeDomainsEXT() const
19104  {
19107  "Function <vkGetPhysicalDeviceCalibrateableTimeDomainsEXT> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
19108 
19109  std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR> timeDomains;
19110  uint32_t timeDomainCount;
19112  do
19113  {
19114  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
19115  getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), &timeDomainCount, nullptr ) );
19116  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && timeDomainCount )
19117  {
19118  timeDomains.resize( timeDomainCount );
19119  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(
19120  static_cast<VkPhysicalDevice>( m_physicalDevice ), &timeDomainCount, reinterpret_cast<VkTimeDomainKHR *>( timeDomains.data() ) ) );
19121  }
19122  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
19123  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsEXT" );
19124  VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() );
19125  if ( timeDomainCount < timeDomains.size() )
19126  {
19127  timeDomains.resize( timeDomainCount );
19128  }
19129  return timeDomains;
19130  }
19131 
19132  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<std::vector<uint64_t>, uint64_t> Device::getCalibratedTimestampsEXT(
19133  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos ) const
19134  {
19135  VULKAN_HPP_ASSERT( getDispatcher()->vkGetCalibratedTimestampsEXT &&
19136  "Function <vkGetCalibratedTimestampsEXT> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
19137 
19138  std::pair<std::vector<uint64_t>, uint64_t> data_( std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) );
19139  std::vector<uint64_t> & timestamps = data_.first;
19140  uint64_t & maxDeviation = data_.second;
19142  getDispatcher()->vkGetCalibratedTimestampsEXT( static_cast<VkDevice>( m_device ),
19143  timestampInfos.size(),
19144  reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( timestampInfos.data() ),
19145  timestamps.data(),
19146  &maxDeviation ) );
19147  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" );
19148 
19149  return data_;
19150  }
19151 
19152  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<uint64_t, uint64_t>
19153  Device::getCalibratedTimestampEXT( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR & timestampInfo ) const
19154  {
19155  VULKAN_HPP_ASSERT( getDispatcher()->vkGetCalibratedTimestampsEXT &&
19156  "Function <vkGetCalibratedTimestampsEXT> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
19157 
19158  std::pair<uint64_t, uint64_t> data_;
19159  uint64_t & timestamp = data_.first;
19160  uint64_t & maxDeviation = data_.second;
19161  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetCalibratedTimestampsEXT(
19162  static_cast<VkDevice>( m_device ), 1, reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( &timestampInfo ), &timestamp, &maxDeviation ) );
19163  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampEXT" );
19164 
19165  return data_;
19166  }
19167 
19168  //=== VK_NV_mesh_shader ===
19169 
19170  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask ) const VULKAN_HPP_NOEXCEPT
19171  {
19172  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksNV && "Function <vkCmdDrawMeshTasksNV> requires <VK_NV_mesh_shader>" );
19173 
19174  getDispatcher()->vkCmdDrawMeshTasksNV( static_cast<VkCommandBuffer>( m_commandBuffer ), taskCount, firstTask );
19175  }
19176 
19177  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectNV( VULKAN_HPP_NAMESPACE::Buffer buffer,
19179  uint32_t drawCount,
19180  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
19181  {
19182  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksIndirectNV && "Function <vkCmdDrawMeshTasksIndirectNV> requires <VK_NV_mesh_shader>" );
19183 
19184  getDispatcher()->vkCmdDrawMeshTasksIndirectNV(
19185  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
19186  }
19187 
19188  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountNV( VULKAN_HPP_NAMESPACE::Buffer buffer,
19190  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
19191  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
19192  uint32_t maxDrawCount,
19193  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
19194  {
19195  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksIndirectCountNV && "Function <vkCmdDrawMeshTasksIndirectCountNV> requires <VK_NV_mesh_shader>" );
19196 
19197  getDispatcher()->vkCmdDrawMeshTasksIndirectCountNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
19198  static_cast<VkBuffer>( buffer ),
19199  static_cast<VkDeviceSize>( offset ),
19200  static_cast<VkBuffer>( countBuffer ),
19201  static_cast<VkDeviceSize>( countBufferOffset ),
19202  maxDrawCount,
19203  stride );
19204  }
19205 
19206  //=== VK_NV_scissor_exclusive ===
19207 
19208  VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorEnableNV(
19209  uint32_t firstExclusiveScissor,
19210  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & exclusiveScissorEnables ) const VULKAN_HPP_NOEXCEPT
19211  {
19213  "Function <vkCmdSetExclusiveScissorEnableNV> requires <VK_NV_scissor_exclusive>" );
19214 
19215  getDispatcher()->vkCmdSetExclusiveScissorEnableNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
19216  firstExclusiveScissor,
19217  exclusiveScissorEnables.size(),
19218  reinterpret_cast<const VkBool32 *>( exclusiveScissorEnables.data() ) );
19219  }
19220 
19221  VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV(
19222  uint32_t firstExclusiveScissor, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & exclusiveScissors ) const VULKAN_HPP_NOEXCEPT
19223  {
19224  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetExclusiveScissorNV && "Function <vkCmdSetExclusiveScissorNV> requires <VK_NV_scissor_exclusive>" );
19225 
19226  getDispatcher()->vkCmdSetExclusiveScissorNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
19227  firstExclusiveScissor,
19228  exclusiveScissors.size(),
19229  reinterpret_cast<const VkRect2D *>( exclusiveScissors.data() ) );
19230  }
19231 
19232  //=== VK_NV_device_diagnostic_checkpoints ===
19233 
19234  template <typename CheckpointMarkerType>
19235  VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV( CheckpointMarkerType const & checkpointMarker ) const VULKAN_HPP_NOEXCEPT
19236  {
19237  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCheckpointNV && "Function <vkCmdSetCheckpointNV> requires <VK_NV_device_diagnostic_checkpoints>" );
19238 
19239  getDispatcher()->vkCmdSetCheckpointNV( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const void *>( &checkpointMarker ) );
19240  }
19241 
19242  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV> Queue::getCheckpointDataNV() const
19243  {
19244  VULKAN_HPP_ASSERT( getDispatcher()->vkGetQueueCheckpointDataNV &&
19245  "Function <vkGetQueueCheckpointDataNV> requires <VK_NV_device_diagnostic_checkpoints>" );
19246 
19247  std::vector<VULKAN_HPP_NAMESPACE::CheckpointDataNV> checkpointData;
19248  uint32_t checkpointDataCount;
19249  getDispatcher()->vkGetQueueCheckpointDataNV( static_cast<VkQueue>( m_queue ), &checkpointDataCount, nullptr );
19250  checkpointData.resize( checkpointDataCount );
19251  getDispatcher()->vkGetQueueCheckpointDataNV(
19252  static_cast<VkQueue>( m_queue ), &checkpointDataCount, reinterpret_cast<VkCheckpointDataNV *>( checkpointData.data() ) );
19253 
19254  VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() );
19255  if ( checkpointDataCount < checkpointData.size() )
19256  {
19257  checkpointData.resize( checkpointDataCount );
19258  }
19259  return checkpointData;
19260  }
19261 
19262  //=== VK_KHR_timeline_semaphore ===
19263 
19264  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Semaphore::getCounterValueKHR() const
19265  {
19267  "Function <vkGetSemaphoreCounterValueKHR> requires <VK_KHR_timeline_semaphore> or <VK_VERSION_1_2>" );
19268 
19269  uint64_t value;
19271  getDispatcher()->vkGetSemaphoreCounterValueKHR( static_cast<VkDevice>( m_device ), static_cast<VkSemaphore>( m_semaphore ), &value ) );
19272  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Semaphore::getCounterValueKHR" );
19273 
19274  return value;
19275  }
19276 
19277  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Device::waitSemaphoresKHR( const VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo & waitInfo,
19278  uint64_t timeout ) const
19279  {
19280  VULKAN_HPP_ASSERT( getDispatcher()->vkWaitSemaphoresKHR && "Function <vkWaitSemaphoresKHR> requires <VK_KHR_timeline_semaphore> or <VK_VERSION_1_2>" );
19281 
19283  getDispatcher()->vkWaitSemaphoresKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreWaitInfo *>( &waitInfo ), timeout ) );
19284  resultCheck(
19285  result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphoresKHR", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout } );
19286 
19287  return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
19288  }
19289 
19290  VULKAN_HPP_INLINE void Device::signalSemaphoreKHR( const VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo & signalInfo ) const
19291  {
19292  VULKAN_HPP_ASSERT( getDispatcher()->vkSignalSemaphoreKHR && "Function <vkSignalSemaphoreKHR> requires <VK_KHR_timeline_semaphore> or <VK_VERSION_1_2>" );
19293 
19295  getDispatcher()->vkSignalSemaphoreKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreSignalInfo *>( &signalInfo ) ) );
19296  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::signalSemaphoreKHR" );
19297  }
19298 
19299  //=== VK_INTEL_performance_query ===
19300 
19301  VULKAN_HPP_INLINE void Device::initializePerformanceApiINTEL( const VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL & initializeInfo ) const
19302  {
19304  "Function <vkInitializePerformanceApiINTEL> requires <VK_INTEL_performance_query>" );
19305 
19306  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkInitializePerformanceApiINTEL(
19307  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkInitializePerformanceApiInfoINTEL *>( &initializeInfo ) ) );
19308  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::initializePerformanceApiINTEL" );
19309  }
19310 
19311  VULKAN_HPP_INLINE void Device::uninitializePerformanceApiINTEL() const VULKAN_HPP_NOEXCEPT
19312  {
19314  "Function <vkUninitializePerformanceApiINTEL> requires <VK_INTEL_performance_query>" );
19315 
19316  getDispatcher()->vkUninitializePerformanceApiINTEL( static_cast<VkDevice>( m_device ) );
19317  }
19318 
19319  VULKAN_HPP_INLINE void CommandBuffer::setPerformanceMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL & markerInfo ) const
19320  {
19321  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetPerformanceMarkerINTEL && "Function <vkCmdSetPerformanceMarkerINTEL> requires <VK_INTEL_performance_query>" );
19322 
19323  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCmdSetPerformanceMarkerINTEL(
19324  static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkPerformanceMarkerInfoINTEL *>( &markerInfo ) ) );
19325  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceMarkerINTEL" );
19326  }
19327 
19328  VULKAN_HPP_INLINE void CommandBuffer::setPerformanceStreamMarkerINTEL( const VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL & markerInfo ) const
19329  {
19331  "Function <vkCmdSetPerformanceStreamMarkerINTEL> requires <VK_INTEL_performance_query>" );
19332 
19333  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCmdSetPerformanceStreamMarkerINTEL(
19334  static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkPerformanceStreamMarkerInfoINTEL *>( &markerInfo ) ) );
19335  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceStreamMarkerINTEL" );
19336  }
19337 
19338  VULKAN_HPP_INLINE void CommandBuffer::setPerformanceOverrideINTEL( const VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL & overrideInfo ) const
19339  {
19341  "Function <vkCmdSetPerformanceOverrideINTEL> requires <VK_INTEL_performance_query>" );
19342 
19343  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCmdSetPerformanceOverrideINTEL(
19344  static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkPerformanceOverrideInfoINTEL *>( &overrideInfo ) ) );
19345  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceOverrideINTEL" );
19346  }
19347 
19349  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PerformanceConfigurationINTEL>::Type
19350  Device::acquirePerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const & acquireInfo ) const
19352  {
19353  VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration;
19355  getDispatcher()->vkAcquirePerformanceConfigurationINTEL( static_cast<VkDevice>( m_device ),
19356  reinterpret_cast<const VkPerformanceConfigurationAcquireInfoINTEL *>( &acquireInfo ),
19357  reinterpret_cast<VkPerformanceConfigurationINTEL *>( &configuration ) ) );
19358  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
19359  {
19360 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
19361  return VULKAN_HPP_UNEXPECTED( result );
19362 # else
19363  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::acquirePerformanceConfigurationINTEL" );
19364 # endif
19365  }
19366 
19367  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PerformanceConfigurationINTEL(
19368  *this, *reinterpret_cast<VkPerformanceConfigurationINTEL *>( &configuration ) );
19369  }
19370 
19371  VULKAN_HPP_INLINE void Queue::setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration ) const
19372  {
19374  "Function <vkQueueSetPerformanceConfigurationINTEL> requires <VK_INTEL_performance_query>" );
19375 
19376  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkQueueSetPerformanceConfigurationINTEL(
19377  static_cast<VkQueue>( m_queue ), static_cast<VkPerformanceConfigurationINTEL>( configuration ) ) );
19378  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::setPerformanceConfigurationINTEL" );
19379  }
19380 
19381  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::PerformanceValueINTEL
19382  Device::getPerformanceParameterINTEL( VULKAN_HPP_NAMESPACE::PerformanceParameterTypeINTEL parameter ) const
19383  {
19384  VULKAN_HPP_ASSERT( getDispatcher()->vkGetPerformanceParameterINTEL && "Function <vkGetPerformanceParameterINTEL> requires <VK_INTEL_performance_query>" );
19385 
19386  VULKAN_HPP_NAMESPACE::PerformanceValueINTEL value;
19387  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPerformanceParameterINTEL(
19388  static_cast<VkDevice>( m_device ), static_cast<VkPerformanceParameterTypeINTEL>( parameter ), reinterpret_cast<VkPerformanceValueINTEL *>( &value ) ) );
19389  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPerformanceParameterINTEL" );
19390 
19391  return value;
19392  }
19393 
19394  //=== VK_AMD_display_native_hdr ===
19395 
19396  VULKAN_HPP_INLINE void SwapchainKHR::setLocalDimmingAMD( VULKAN_HPP_NAMESPACE::Bool32 localDimmingEnable ) const VULKAN_HPP_NOEXCEPT
19397  {
19398  VULKAN_HPP_ASSERT( getDispatcher()->vkSetLocalDimmingAMD && "Function <vkSetLocalDimmingAMD> requires <VK_AMD_display_native_hdr>" );
19399 
19400  getDispatcher()->vkSetLocalDimmingAMD(
19401  static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), static_cast<VkBool32>( localDimmingEnable ) );
19402  }
19403 
19404 # if defined( VK_USE_PLATFORM_FUCHSIA )
19405  //=== VK_FUCHSIA_imagepipe_surface ===
19406 
19408  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type
19409  Instance::createImagePipeSurfaceFUCHSIA( VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA const & createInfo,
19410  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
19412  {
19413  VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
19414  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateImagePipeSurfaceFUCHSIA(
19415  static_cast<VkInstance>( m_instance ),
19416  reinterpret_cast<const VkImagePipeSurfaceCreateInfoFUCHSIA *>( &createInfo ),
19417  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
19418  reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
19419  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
19420  {
19421 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
19422  return VULKAN_HPP_UNEXPECTED( result );
19423 # else
19424  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Instance::createImagePipeSurfaceFUCHSIA" );
19425 # endif
19426  }
19427 
19428  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, *reinterpret_cast<VkSurfaceKHR *>( &surface ), allocator );
19429  }
19430 # endif /*VK_USE_PLATFORM_FUCHSIA*/
19431 
19432 # if defined( VK_USE_PLATFORM_METAL_EXT )
19433  //=== VK_EXT_metal_surface ===
19434 
19436  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type
19437  Instance::createMetalSurfaceEXT( VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT const & createInfo,
19438  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
19440  {
19441  VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
19442  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateMetalSurfaceEXT(
19443  static_cast<VkInstance>( m_instance ),
19444  reinterpret_cast<const VkMetalSurfaceCreateInfoEXT *>( &createInfo ),
19445  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
19446  reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
19447  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
19448  {
19449 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
19450  return VULKAN_HPP_UNEXPECTED( result );
19451 # else
19452  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Instance::createMetalSurfaceEXT" );
19453 # endif
19454  }
19455 
19456  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, *reinterpret_cast<VkSurfaceKHR *>( &surface ), allocator );
19457  }
19458 # endif /*VK_USE_PLATFORM_METAL_EXT*/
19459 
19460  //=== VK_KHR_fragment_shading_rate ===
19461 
19462  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>
19463  PhysicalDevice::getFragmentShadingRatesKHR() const
19464  {
19466  "Function <vkGetPhysicalDeviceFragmentShadingRatesKHR> requires <VK_KHR_fragment_shading_rate>" );
19467 
19468  std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR> fragmentShadingRates;
19469  uint32_t fragmentShadingRateCount;
19471  do
19472  {
19473  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceFragmentShadingRatesKHR(
19474  static_cast<VkPhysicalDevice>( m_physicalDevice ), &fragmentShadingRateCount, nullptr ) );
19475  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && fragmentShadingRateCount )
19476  {
19477  fragmentShadingRates.resize( fragmentShadingRateCount );
19478  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceFragmentShadingRatesKHR(
19479  static_cast<VkPhysicalDevice>( m_physicalDevice ),
19480  &fragmentShadingRateCount,
19481  reinterpret_cast<VkPhysicalDeviceFragmentShadingRateKHR *>( fragmentShadingRates.data() ) ) );
19482  }
19483  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
19484  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getFragmentShadingRatesKHR" );
19485  VULKAN_HPP_ASSERT( fragmentShadingRateCount <= fragmentShadingRates.size() );
19486  if ( fragmentShadingRateCount < fragmentShadingRates.size() )
19487  {
19488  fragmentShadingRates.resize( fragmentShadingRateCount );
19489  }
19490  return fragmentShadingRates;
19491  }
19492 
19493  VULKAN_HPP_INLINE void
19494  CommandBuffer::setFragmentShadingRateKHR( const VULKAN_HPP_NAMESPACE::Extent2D & fragmentSize,
19496  {
19498  "Function <vkCmdSetFragmentShadingRateKHR> requires <VK_KHR_fragment_shading_rate>" );
19499 
19500  getDispatcher()->vkCmdSetFragmentShadingRateKHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
19501  reinterpret_cast<const VkExtent2D *>( &fragmentSize ),
19502  reinterpret_cast<const VkFragmentShadingRateCombinerOpKHR *>( combinerOps ) );
19503  }
19504 
19505  //=== VK_EXT_buffer_device_address ===
19506 
19508  Device::getBufferAddressEXT( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT
19509  {
19511  getDispatcher()->vkGetBufferDeviceAddressEXT &&
19512  "Function <vkGetBufferDeviceAddressEXT> requires <VK_EXT_buffer_device_address> or <VK_KHR_buffer_device_address> or <VK_VERSION_1_2>" );
19513 
19514  VkDeviceAddress result =
19515  getDispatcher()->vkGetBufferDeviceAddressEXT( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
19516 
19517  return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>( result );
19518  }
19519 
19520  //=== VK_EXT_tooling_info ===
19521 
19522  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties> PhysicalDevice::getToolPropertiesEXT() const
19523  {
19525  "Function <vkGetPhysicalDeviceToolPropertiesEXT> requires <VK_EXT_tooling_info> or <VK_VERSION_1_3>" );
19526 
19527  std::vector<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties> toolProperties;
19528  uint32_t toolCount;
19530  do
19531  {
19532  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
19533  getDispatcher()->vkGetPhysicalDeviceToolPropertiesEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), &toolCount, nullptr ) );
19534  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && toolCount )
19535  {
19536  toolProperties.resize( toolCount );
19537  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceToolPropertiesEXT(
19538  static_cast<VkPhysicalDevice>( m_physicalDevice ), &toolCount, reinterpret_cast<VkPhysicalDeviceToolProperties *>( toolProperties.data() ) ) );
19539  }
19540  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
19541  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolPropertiesEXT" );
19542  VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() );
19543  if ( toolCount < toolProperties.size() )
19544  {
19545  toolProperties.resize( toolCount );
19546  }
19547  return toolProperties;
19548  }
19549 
19550  //=== VK_KHR_present_wait ===
19551 
19552  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result SwapchainKHR::waitForPresent( uint64_t presentId, uint64_t timeout ) const
19553  {
19554  VULKAN_HPP_ASSERT( getDispatcher()->vkWaitForPresentKHR && "Function <vkWaitForPresentKHR> requires <VK_KHR_present_wait>" );
19555 
19557  getDispatcher()->vkWaitForPresentKHR( static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), presentId, timeout ) );
19558  resultCheck( result,
19559  VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::waitForPresent",
19560  { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eTimeout, VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } );
19561 
19562  return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
19563  }
19564 
19565  //=== VK_NV_cooperative_matrix ===
19566 
19567  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>
19568  PhysicalDevice::getCooperativeMatrixPropertiesNV() const
19569  {
19571  "Function <vkGetPhysicalDeviceCooperativeMatrixPropertiesNV> requires <VK_NV_cooperative_matrix>" );
19572 
19573  std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV> properties;
19574  uint32_t propertyCount;
19576  do
19577  {
19578  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
19579  getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, nullptr ) );
19580  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount )
19581  {
19582  properties.resize( propertyCount );
19583  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(
19584  static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, reinterpret_cast<VkCooperativeMatrixPropertiesNV *>( properties.data() ) ) );
19585  }
19586  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
19587  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixPropertiesNV" );
19588  VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
19589  if ( propertyCount < properties.size() )
19590  {
19591  properties.resize( propertyCount );
19592  }
19593  return properties;
19594  }
19595 
19596  //=== VK_NV_coverage_reduction_mode ===
19597 
19598  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>
19599  PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV() const
19600  {
19602  "Function <vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV> requires <VK_NV_coverage_reduction_mode>" );
19603 
19604  std::vector<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV> combinations;
19605  uint32_t combinationCount;
19607  do
19608  {
19609  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
19610  static_cast<VkPhysicalDevice>( m_physicalDevice ), &combinationCount, nullptr ) );
19611  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && combinationCount )
19612  {
19613  combinations.resize( combinationCount );
19614  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
19615  static_cast<VkPhysicalDevice>( m_physicalDevice ),
19616  &combinationCount,
19617  reinterpret_cast<VkFramebufferMixedSamplesCombinationNV *>( combinations.data() ) ) );
19618  }
19619  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
19620  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV" );
19621  VULKAN_HPP_ASSERT( combinationCount <= combinations.size() );
19622  if ( combinationCount < combinations.size() )
19623  {
19624  combinations.resize( combinationCount );
19625  }
19626  return combinations;
19627  }
19628 
19629 # if defined( VK_USE_PLATFORM_WIN32_KHR )
19630  //=== VK_EXT_full_screen_exclusive ===
19631 
19632  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR>
19633  PhysicalDevice::getSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const
19634  {
19635  VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfacePresentModes2EXT &&
19636  "Function <vkGetPhysicalDeviceSurfacePresentModes2EXT> requires <VK_EXT_full_screen_exclusive>" );
19637 
19638  std::vector<VULKAN_HPP_NAMESPACE::PresentModeKHR> presentModes;
19639  uint32_t presentModeCount;
19641  do
19642  {
19643  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
19644  getDispatcher()->vkGetPhysicalDeviceSurfacePresentModes2EXT( static_cast<VkPhysicalDevice>( m_physicalDevice ),
19645  reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
19646  &presentModeCount,
19647  nullptr ) );
19648  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && presentModeCount )
19649  {
19650  presentModes.resize( presentModeCount );
19651  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
19652  getDispatcher()->vkGetPhysicalDeviceSurfacePresentModes2EXT( static_cast<VkPhysicalDevice>( m_physicalDevice ),
19653  reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
19654  &presentModeCount,
19655  reinterpret_cast<VkPresentModeKHR *>( presentModes.data() ) ) );
19656  }
19657  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
19658  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModes2EXT" );
19659  VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() );
19660  if ( presentModeCount < presentModes.size() )
19661  {
19662  presentModes.resize( presentModeCount );
19663  }
19664  return presentModes;
19665  }
19666 
19667  VULKAN_HPP_INLINE void SwapchainKHR::acquireFullScreenExclusiveModeEXT() const
19668  {
19669  VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireFullScreenExclusiveModeEXT &&
19670  "Function <vkAcquireFullScreenExclusiveModeEXT> requires <VK_EXT_full_screen_exclusive>" );
19671 
19673  getDispatcher()->vkAcquireFullScreenExclusiveModeEXT( static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ) ) );
19674  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::acquireFullScreenExclusiveModeEXT" );
19675  }
19676 
19677  VULKAN_HPP_INLINE void SwapchainKHR::releaseFullScreenExclusiveModeEXT() const
19678  {
19679  VULKAN_HPP_ASSERT( getDispatcher()->vkReleaseFullScreenExclusiveModeEXT &&
19680  "Function <vkReleaseFullScreenExclusiveModeEXT> requires <VK_EXT_full_screen_exclusive>" );
19681 
19683  getDispatcher()->vkReleaseFullScreenExclusiveModeEXT( static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ) ) );
19684  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::releaseFullScreenExclusiveModeEXT" );
19685  }
19686 
19688  Device::getGroupSurfacePresentModes2EXT( const VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const
19689  {
19690  VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceGroupSurfacePresentModes2EXT &&
19691  "Function <vkGetDeviceGroupSurfacePresentModes2EXT> requires <VK_EXT_full_screen_exclusive>" );
19692 
19695  getDispatcher()->vkGetDeviceGroupSurfacePresentModes2EXT( static_cast<VkDevice>( m_device ),
19696  reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR *>( &surfaceInfo ),
19697  reinterpret_cast<VkDeviceGroupPresentModeFlagsKHR *>( &modes ) ) );
19698  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModes2EXT" );
19699 
19700  return modes;
19701  }
19702 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
19703 
19704  //=== VK_EXT_headless_surface ===
19705 
19707  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type
19708  Instance::createHeadlessSurfaceEXT( VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT const & createInfo,
19709  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
19711  {
19712  VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
19713  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateHeadlessSurfaceEXT(
19714  static_cast<VkInstance>( m_instance ),
19715  reinterpret_cast<const VkHeadlessSurfaceCreateInfoEXT *>( &createInfo ),
19716  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
19717  reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
19718  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
19719  {
19720 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
19721  return VULKAN_HPP_UNEXPECTED( result );
19722 # else
19723  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Instance::createHeadlessSurfaceEXT" );
19724 # endif
19725  }
19726 
19727  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, *reinterpret_cast<VkSurfaceKHR *>( &surface ), allocator );
19728  }
19729 
19730  //=== VK_KHR_buffer_device_address ===
19731 
19733  Device::getBufferAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT
19734  {
19736  getDispatcher()->vkGetBufferDeviceAddressKHR &&
19737  "Function <vkGetBufferDeviceAddressKHR> requires <VK_EXT_buffer_device_address> or <VK_KHR_buffer_device_address> or <VK_VERSION_1_2>" );
19738 
19739  VkDeviceAddress result =
19740  getDispatcher()->vkGetBufferDeviceAddressKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
19741 
19742  return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>( result );
19743  }
19744 
19746  Device::getBufferOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT
19747  {
19749  "Function <vkGetBufferOpaqueCaptureAddressKHR> requires <VK_KHR_buffer_device_address> or <VK_VERSION_1_2>" );
19750 
19751  uint64_t result =
19752  getDispatcher()->vkGetBufferOpaqueCaptureAddressKHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferDeviceAddressInfo *>( &info ) );
19753 
19754  return result;
19755  }
19756 
19758  Device::getMemoryOpaqueCaptureAddressKHR( const VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo & info ) const VULKAN_HPP_NOEXCEPT
19759  {
19761  "Function <vkGetDeviceMemoryOpaqueCaptureAddressKHR> requires <VK_KHR_buffer_device_address> or <VK_VERSION_1_2>" );
19762 
19763  uint64_t result = getDispatcher()->vkGetDeviceMemoryOpaqueCaptureAddressKHR( static_cast<VkDevice>( m_device ),
19764  reinterpret_cast<const VkDeviceMemoryOpaqueCaptureAddressInfo *>( &info ) );
19765 
19766  return result;
19767  }
19768 
19769  //=== VK_EXT_line_rasterization ===
19770 
19771  VULKAN_HPP_INLINE void CommandBuffer::setLineStippleEXT( uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT
19772  {
19773  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLineStippleEXT && "Function <vkCmdSetLineStippleEXT> requires <VK_EXT_line_rasterization>" );
19774 
19775  getDispatcher()->vkCmdSetLineStippleEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), lineStippleFactor, lineStipplePattern );
19776  }
19777 
19778  //=== VK_EXT_host_query_reset ===
19779 
19780  VULKAN_HPP_INLINE void QueryPool::resetEXT( uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT
19781  {
19782  VULKAN_HPP_ASSERT( getDispatcher()->vkResetQueryPoolEXT && "Function <vkResetQueryPoolEXT> requires <VK_EXT_host_query_reset> or <VK_VERSION_1_2>" );
19783 
19784  getDispatcher()->vkResetQueryPoolEXT( static_cast<VkDevice>( m_device ), static_cast<VkQueryPool>( m_queryPool ), firstQuery, queryCount );
19785  }
19786 
19787  //=== VK_EXT_extended_dynamic_state ===
19788 
19789  VULKAN_HPP_INLINE void CommandBuffer::setCullModeEXT( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT
19790  {
19791  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCullModeEXT &&
19792  "Function <vkCmdSetCullModeEXT> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
19793 
19794  getDispatcher()->vkCmdSetCullModeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkCullModeFlags>( cullMode ) );
19795  }
19796 
19797  VULKAN_HPP_INLINE void CommandBuffer::setFrontFaceEXT( VULKAN_HPP_NAMESPACE::FrontFace frontFace ) const VULKAN_HPP_NOEXCEPT
19798  {
19799  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetFrontFaceEXT &&
19800  "Function <vkCmdSetFrontFaceEXT> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
19801 
19802  getDispatcher()->vkCmdSetFrontFaceEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkFrontFace>( frontFace ) );
19803  }
19804 
19805  VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveTopologyEXT( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT
19806  {
19807  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetPrimitiveTopologyEXT &&
19808  "Function <vkCmdSetPrimitiveTopologyEXT> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
19809 
19810  getDispatcher()->vkCmdSetPrimitiveTopologyEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPrimitiveTopology>( primitiveTopology ) );
19811  }
19812 
19813  VULKAN_HPP_INLINE void CommandBuffer::setViewportWithCountEXT(
19814  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Viewport> const & viewports ) const VULKAN_HPP_NOEXCEPT
19815  {
19816  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetViewportWithCountEXT &&
19817  "Function <vkCmdSetViewportWithCountEXT> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
19818 
19819  getDispatcher()->vkCmdSetViewportWithCountEXT(
19820  static_cast<VkCommandBuffer>( m_commandBuffer ), viewports.size(), reinterpret_cast<const VkViewport *>( viewports.data() ) );
19821  }
19822 
19823  VULKAN_HPP_INLINE void
19824  CommandBuffer::setScissorWithCountEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Rect2D> const & scissors ) const VULKAN_HPP_NOEXCEPT
19825  {
19826  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetScissorWithCountEXT &&
19827  "Function <vkCmdSetScissorWithCountEXT> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
19828 
19829  getDispatcher()->vkCmdSetScissorWithCountEXT(
19830  static_cast<VkCommandBuffer>( m_commandBuffer ), scissors.size(), reinterpret_cast<const VkRect2D *>( scissors.data() ) );
19831  }
19832 
19833  VULKAN_HPP_INLINE void
19834  CommandBuffer::bindVertexBuffers2EXT( uint32_t firstBinding,
19835  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Buffer> const & buffers,
19836  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets,
19837  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & sizes,
19838  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & strides ) const
19839  {
19840  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindVertexBuffers2EXT &&
19841  "Function <vkCmdBindVertexBuffers2EXT> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
19842 # ifdef VULKAN_HPP_NO_EXCEPTIONS
19843  VULKAN_HPP_ASSERT( buffers.size() == offsets.size() );
19844  VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() );
19845  VULKAN_HPP_ASSERT( strides.empty() || buffers.size() == strides.size() );
19846 # else
19847  if ( buffers.size() != offsets.size() )
19848  {
19849  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != offsets.size()" );
19850  }
19851  if ( !sizes.empty() && buffers.size() != sizes.size() )
19852  {
19853  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != sizes.size()" );
19854  }
19855  if ( !strides.empty() && buffers.size() != strides.size() )
19856  {
19857  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != strides.size()" );
19858  }
19859 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
19860 
19861  getDispatcher()->vkCmdBindVertexBuffers2EXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
19862  firstBinding,
19863  buffers.size(),
19864  reinterpret_cast<const VkBuffer *>( buffers.data() ),
19865  reinterpret_cast<const VkDeviceSize *>( offsets.data() ),
19866  reinterpret_cast<const VkDeviceSize *>( sizes.data() ),
19867  reinterpret_cast<const VkDeviceSize *>( strides.data() ) );
19868  }
19869 
19870  VULKAN_HPP_INLINE void CommandBuffer::setDepthTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT
19871  {
19872  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthTestEnableEXT &&
19873  "Function <vkCmdSetDepthTestEnableEXT> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
19874 
19875  getDispatcher()->vkCmdSetDepthTestEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthTestEnable ) );
19876  }
19877 
19878  VULKAN_HPP_INLINE void CommandBuffer::setDepthWriteEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT
19879  {
19880  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthWriteEnableEXT &&
19881  "Function <vkCmdSetDepthWriteEnableEXT> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
19882 
19883  getDispatcher()->vkCmdSetDepthWriteEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthWriteEnable ) );
19884  }
19885 
19886  VULKAN_HPP_INLINE void CommandBuffer::setDepthCompareOpEXT( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT
19887  {
19888  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthCompareOpEXT &&
19889  "Function <vkCmdSetDepthCompareOpEXT> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
19890 
19891  getDispatcher()->vkCmdSetDepthCompareOpEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkCompareOp>( depthCompareOp ) );
19892  }
19893 
19894  VULKAN_HPP_INLINE void CommandBuffer::setDepthBoundsTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT
19895  {
19897  "Function <vkCmdSetDepthBoundsTestEnableEXT> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
19898 
19899  getDispatcher()->vkCmdSetDepthBoundsTestEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthBoundsTestEnable ) );
19900  }
19901 
19902  VULKAN_HPP_INLINE void CommandBuffer::setStencilTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT
19903  {
19904  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilTestEnableEXT &&
19905  "Function <vkCmdSetStencilTestEnableEXT> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
19906 
19907  getDispatcher()->vkCmdSetStencilTestEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( stencilTestEnable ) );
19908  }
19909 
19910  VULKAN_HPP_INLINE void CommandBuffer::setStencilOpEXT( VULKAN_HPP_NAMESPACE::StencilFaceFlags faceMask,
19913  VULKAN_HPP_NAMESPACE::StencilOp depthFailOp,
19915  {
19916  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilOpEXT &&
19917  "Function <vkCmdSetStencilOpEXT> requires <VK_EXT_extended_dynamic_state> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
19918 
19919  getDispatcher()->vkCmdSetStencilOpEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
19920  static_cast<VkStencilFaceFlags>( faceMask ),
19921  static_cast<VkStencilOp>( failOp ),
19922  static_cast<VkStencilOp>( passOp ),
19923  static_cast<VkStencilOp>( depthFailOp ),
19924  static_cast<VkCompareOp>( compareOp ) );
19925  }
19926 
19927  //=== VK_KHR_deferred_host_operations ===
19928 
19930  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR>::Type
19931  Device::createDeferredOperationKHR( VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
19933  {
19934  VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation;
19935  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateDeferredOperationKHR(
19936  static_cast<VkDevice>( m_device ),
19937  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
19938  reinterpret_cast<VkDeferredOperationKHR *>( &deferredOperation ) ) );
19939  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
19940  {
19941 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
19942  return VULKAN_HPP_UNEXPECTED( result );
19943 # else
19944  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createDeferredOperationKHR" );
19945 # endif
19946  }
19947 
19948  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR(
19949  *this, *reinterpret_cast<VkDeferredOperationKHR *>( &deferredOperation ), allocator );
19950  }
19951 
19952  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t DeferredOperationKHR::getMaxConcurrency() const VULKAN_HPP_NOEXCEPT
19953  {
19955  "Function <vkGetDeferredOperationMaxConcurrencyKHR> requires <VK_KHR_deferred_host_operations>" );
19956 
19957  uint32_t result =
19958  getDispatcher()->vkGetDeferredOperationMaxConcurrencyKHR( static_cast<VkDevice>( m_device ), static_cast<VkDeferredOperationKHR>( m_operation ) );
19959 
19960  return result;
19961  }
19962 
19964  {
19966  "Function <vkGetDeferredOperationResultKHR> requires <VK_KHR_deferred_host_operations>" );
19967 
19969  getDispatcher()->vkGetDeferredOperationResultKHR( static_cast<VkDevice>( m_device ), static_cast<VkDeferredOperationKHR>( m_operation ) ) );
19970 
19971  return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
19972  }
19973 
19975  {
19976  VULKAN_HPP_ASSERT( getDispatcher()->vkDeferredOperationJoinKHR && "Function <vkDeferredOperationJoinKHR> requires <VK_KHR_deferred_host_operations>" );
19977 
19979  getDispatcher()->vkDeferredOperationJoinKHR( static_cast<VkDevice>( m_device ), static_cast<VkDeferredOperationKHR>( m_operation ) ) );
19980  resultCheck( result,
19981  VULKAN_HPP_NAMESPACE_STRING "::DeferredOperationKHR::join",
19982  { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eThreadDoneKHR, VULKAN_HPP_NAMESPACE::Result::eThreadIdleKHR } );
19983 
19984  return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
19985  }
19986 
19987  //=== VK_KHR_pipeline_executable_properties ===
19988 
19989  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>
19990  Device::getPipelineExecutablePropertiesKHR( const VULKAN_HPP_NAMESPACE::PipelineInfoKHR & pipelineInfo ) const
19991  {
19993  "Function <vkGetPipelineExecutablePropertiesKHR> requires <VK_KHR_pipeline_executable_properties>" );
19994 
19995  std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR> properties;
19996  uint32_t executableCount;
19998  do
19999  {
20000  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPipelineExecutablePropertiesKHR(
20001  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkPipelineInfoKHR *>( &pipelineInfo ), &executableCount, nullptr ) );
20002  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && executableCount )
20003  {
20004  properties.resize( executableCount );
20005  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
20006  getDispatcher()->vkGetPipelineExecutablePropertiesKHR( static_cast<VkDevice>( m_device ),
20007  reinterpret_cast<const VkPipelineInfoKHR *>( &pipelineInfo ),
20008  &executableCount,
20009  reinterpret_cast<VkPipelineExecutablePropertiesKHR *>( properties.data() ) ) );
20010  }
20011  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
20012  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutablePropertiesKHR" );
20013  VULKAN_HPP_ASSERT( executableCount <= properties.size() );
20014  if ( executableCount < properties.size() )
20015  {
20016  properties.resize( executableCount );
20017  }
20018  return properties;
20019  }
20020 
20021  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR>
20022  Device::getPipelineExecutableStatisticsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo ) const
20023  {
20025  "Function <vkGetPipelineExecutableStatisticsKHR> requires <VK_KHR_pipeline_executable_properties>" );
20026 
20027  std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR> statistics;
20028  uint32_t statisticCount;
20030  do
20031  {
20032  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPipelineExecutableStatisticsKHR(
20033  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ), &statisticCount, nullptr ) );
20034  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && statisticCount )
20035  {
20036  statistics.resize( statisticCount );
20037  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
20038  getDispatcher()->vkGetPipelineExecutableStatisticsKHR( static_cast<VkDevice>( m_device ),
20039  reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ),
20040  &statisticCount,
20041  reinterpret_cast<VkPipelineExecutableStatisticKHR *>( statistics.data() ) ) );
20042  }
20043  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
20044  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableStatisticsKHR" );
20045  VULKAN_HPP_ASSERT( statisticCount <= statistics.size() );
20046  if ( statisticCount < statistics.size() )
20047  {
20048  statistics.resize( statisticCount );
20049  }
20050  return statistics;
20051  }
20052 
20053  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>
20054  Device::getPipelineExecutableInternalRepresentationsKHR( const VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR & executableInfo ) const
20055  {
20057  "Function <vkGetPipelineExecutableInternalRepresentationsKHR> requires <VK_KHR_pipeline_executable_properties>" );
20058 
20059  std::vector<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR> internalRepresentations;
20060  uint32_t internalRepresentationCount;
20062  do
20063  {
20064  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
20065  getDispatcher()->vkGetPipelineExecutableInternalRepresentationsKHR( static_cast<VkDevice>( m_device ),
20066  reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ),
20067  &internalRepresentationCount,
20068  nullptr ) );
20069  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && internalRepresentationCount )
20070  {
20071  internalRepresentations.resize( internalRepresentationCount );
20072  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPipelineExecutableInternalRepresentationsKHR(
20073  static_cast<VkDevice>( m_device ),
20074  reinterpret_cast<const VkPipelineExecutableInfoKHR *>( &executableInfo ),
20075  &internalRepresentationCount,
20076  reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR *>( internalRepresentations.data() ) ) );
20077  }
20078  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
20079  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableInternalRepresentationsKHR" );
20080  VULKAN_HPP_ASSERT( internalRepresentationCount <= internalRepresentations.size() );
20081  if ( internalRepresentationCount < internalRepresentations.size() )
20082  {
20083  internalRepresentations.resize( internalRepresentationCount );
20084  }
20085  return internalRepresentations;
20086  }
20087 
20088  //=== VK_EXT_host_image_copy ===
20089 
20090  VULKAN_HPP_INLINE void Device::copyMemoryToImageEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfoEXT & copyMemoryToImageInfo ) const
20091  {
20092  VULKAN_HPP_ASSERT( getDispatcher()->vkCopyMemoryToImageEXT && "Function <vkCopyMemoryToImageEXT> requires <VK_EXT_host_image_copy>" );
20093 
20094  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCopyMemoryToImageEXT(
20095  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkCopyMemoryToImageInfoEXT *>( &copyMemoryToImageInfo ) ) );
20096  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyMemoryToImageEXT" );
20097  }
20098 
20099  VULKAN_HPP_INLINE void Device::copyImageToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfoEXT & copyImageToMemoryInfo ) const
20100  {
20101  VULKAN_HPP_ASSERT( getDispatcher()->vkCopyImageToMemoryEXT && "Function <vkCopyImageToMemoryEXT> requires <VK_EXT_host_image_copy>" );
20102 
20103  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCopyImageToMemoryEXT(
20104  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkCopyImageToMemoryInfoEXT *>( &copyImageToMemoryInfo ) ) );
20105  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyImageToMemoryEXT" );
20106  }
20107 
20108  VULKAN_HPP_INLINE void Device::copyImageToImageEXT( const VULKAN_HPP_NAMESPACE::CopyImageToImageInfoEXT & copyImageToImageInfo ) const
20109  {
20110  VULKAN_HPP_ASSERT( getDispatcher()->vkCopyImageToImageEXT && "Function <vkCopyImageToImageEXT> requires <VK_EXT_host_image_copy>" );
20111 
20112  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCopyImageToImageEXT(
20113  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkCopyImageToImageInfoEXT *>( &copyImageToImageInfo ) ) );
20114  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyImageToImageEXT" );
20115  }
20116 
20117  VULKAN_HPP_INLINE void Device::transitionImageLayoutEXT(
20118  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfoEXT> const & transitions ) const
20119  {
20120  VULKAN_HPP_ASSERT( getDispatcher()->vkTransitionImageLayoutEXT && "Function <vkTransitionImageLayoutEXT> requires <VK_EXT_host_image_copy>" );
20121 
20122  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkTransitionImageLayoutEXT(
20123  static_cast<VkDevice>( m_device ), transitions.size(), reinterpret_cast<const VkHostImageLayoutTransitionInfoEXT *>( transitions.data() ) ) );
20124  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::transitionImageLayoutEXT" );
20125  }
20126 
20127  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR
20128  Image::getSubresourceLayout2EXT( const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR & subresource ) const VULKAN_HPP_NOEXCEPT
20129  {
20131  getDispatcher()->vkGetImageSubresourceLayout2EXT &&
20132  "Function <vkGetImageSubresourceLayout2EXT> requires <VK_EXT_host_image_copy> or <VK_EXT_image_compression_control> or <VK_KHR_maintenance5>" );
20133 
20134  VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR layout;
20135  getDispatcher()->vkGetImageSubresourceLayout2EXT( static_cast<VkDevice>( m_device ),
20136  static_cast<VkImage>( m_image ),
20137  reinterpret_cast<const VkImageSubresource2KHR *>( &subresource ),
20138  reinterpret_cast<VkSubresourceLayout2KHR *>( &layout ) );
20139 
20140  return layout;
20141  }
20142 
20143  template <typename X, typename Y, typename... Z>
20144  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
20145  Image::getSubresourceLayout2EXT( const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR & subresource ) const VULKAN_HPP_NOEXCEPT
20146  {
20148  getDispatcher()->vkGetImageSubresourceLayout2EXT &&
20149  "Function <vkGetImageSubresourceLayout2EXT> requires <VK_EXT_host_image_copy> or <VK_EXT_image_compression_control> or <VK_KHR_maintenance5>" );
20150 
20151  VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
20152  VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR & layout = structureChain.template get<VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR>();
20153  getDispatcher()->vkGetImageSubresourceLayout2EXT( static_cast<VkDevice>( m_device ),
20154  static_cast<VkImage>( m_image ),
20155  reinterpret_cast<const VkImageSubresource2KHR *>( &subresource ),
20156  reinterpret_cast<VkSubresourceLayout2KHR *>( &layout ) );
20157 
20158  return structureChain;
20159  }
20160 
20161  //=== VK_KHR_map_memory2 ===
20162 
20163  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE void * Device::mapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR & memoryMapInfo ) const
20164  {
20165  VULKAN_HPP_ASSERT( getDispatcher()->vkMapMemory2KHR && "Function <vkMapMemory2KHR> requires <VK_KHR_map_memory2>" );
20166 
20167  void * pData;
20169  getDispatcher()->vkMapMemory2KHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryMapInfoKHR *>( &memoryMapInfo ), &pData ) );
20170  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::mapMemory2KHR" );
20171 
20172  return pData;
20173  }
20174 
20175  VULKAN_HPP_INLINE void Device::unmapMemory2KHR( const VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR & memoryUnmapInfo ) const VULKAN_HPP_NOEXCEPT
20176  {
20177  VULKAN_HPP_ASSERT( getDispatcher()->vkUnmapMemory2KHR && "Function <vkUnmapMemory2KHR> requires <VK_KHR_map_memory2>" );
20178 
20179  getDispatcher()->vkUnmapMemory2KHR( static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryUnmapInfoKHR *>( &memoryUnmapInfo ) );
20180  }
20181 
20182  //=== VK_EXT_swapchain_maintenance1 ===
20183 
20184  VULKAN_HPP_INLINE void Device::releaseSwapchainImagesEXT( const VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT & releaseInfo ) const
20185  {
20186  VULKAN_HPP_ASSERT( getDispatcher()->vkReleaseSwapchainImagesEXT && "Function <vkReleaseSwapchainImagesEXT> requires <VK_EXT_swapchain_maintenance1>" );
20187 
20188  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkReleaseSwapchainImagesEXT(
20189  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkReleaseSwapchainImagesInfoEXT *>( &releaseInfo ) ) );
20190  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::releaseSwapchainImagesEXT" );
20191  }
20192 
20193  //=== VK_NV_device_generated_commands ===
20194 
20195  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2
20196  Device::getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT
20197  {
20199  "Function <vkGetGeneratedCommandsMemoryRequirementsNV> requires <VK_NV_device_generated_commands>" );
20200 
20201  VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
20202  getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsNV( static_cast<VkDevice>( m_device ),
20203  reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV *>( &info ),
20204  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
20205 
20206  return memoryRequirements;
20207  }
20208 
20209  template <typename X, typename Y, typename... Z>
20210  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
20211  Device::getGeneratedCommandsMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT
20212  {
20214  "Function <vkGetGeneratedCommandsMemoryRequirementsNV> requires <VK_NV_device_generated_commands>" );
20215 
20216  VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
20217  VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
20218  getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsNV( static_cast<VkDevice>( m_device ),
20219  reinterpret_cast<const VkGeneratedCommandsMemoryRequirementsInfoNV *>( &info ),
20220  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
20221 
20222  return structureChain;
20223  }
20224 
20225  VULKAN_HPP_INLINE void
20226  CommandBuffer::preprocessGeneratedCommandsNV( const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo ) const VULKAN_HPP_NOEXCEPT
20227  {
20229  "Function <vkCmdPreprocessGeneratedCommandsNV> requires <VK_NV_device_generated_commands>" );
20230 
20231  getDispatcher()->vkCmdPreprocessGeneratedCommandsNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
20232  reinterpret_cast<const VkGeneratedCommandsInfoNV *>( &generatedCommandsInfo ) );
20233  }
20234 
20235  VULKAN_HPP_INLINE void
20236  CommandBuffer::executeGeneratedCommandsNV( VULKAN_HPP_NAMESPACE::Bool32 isPreprocessed,
20237  const VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV & generatedCommandsInfo ) const VULKAN_HPP_NOEXCEPT
20238  {
20240  "Function <vkCmdExecuteGeneratedCommandsNV> requires <VK_NV_device_generated_commands>" );
20241 
20242  getDispatcher()->vkCmdExecuteGeneratedCommandsNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
20243  static_cast<VkBool32>( isPreprocessed ),
20244  reinterpret_cast<const VkGeneratedCommandsInfoNV *>( &generatedCommandsInfo ) );
20245  }
20246 
20247  VULKAN_HPP_INLINE void CommandBuffer::bindPipelineShaderGroupNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
20248  VULKAN_HPP_NAMESPACE::Pipeline pipeline,
20249  uint32_t groupIndex ) const VULKAN_HPP_NOEXCEPT
20250  {
20252  "Function <vkCmdBindPipelineShaderGroupNV> requires <VK_NV_device_generated_commands>" );
20253 
20254  getDispatcher()->vkCmdBindPipelineShaderGroupNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
20255  static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
20256  static_cast<VkPipeline>( pipeline ),
20257  groupIndex );
20258  }
20259 
20261  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::IndirectCommandsLayoutNV>::Type
20262  Device::createIndirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV const & createInfo,
20263  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
20265  {
20266  VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout;
20267  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateIndirectCommandsLayoutNV(
20268  static_cast<VkDevice>( m_device ),
20269  reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNV *>( &createInfo ),
20270  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
20271  reinterpret_cast<VkIndirectCommandsLayoutNV *>( &indirectCommandsLayout ) ) );
20272  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
20273  {
20274 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
20275  return VULKAN_HPP_UNEXPECTED( result );
20276 # else
20277  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createIndirectCommandsLayoutNV" );
20278 # endif
20279  }
20280 
20281  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::IndirectCommandsLayoutNV(
20282  *this, *reinterpret_cast<VkIndirectCommandsLayoutNV *>( &indirectCommandsLayout ), allocator );
20283  }
20284 
20285  //=== VK_EXT_depth_bias_control ===
20286 
20287  VULKAN_HPP_INLINE void CommandBuffer::setDepthBias2EXT( const VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT & depthBiasInfo ) const VULKAN_HPP_NOEXCEPT
20288  {
20289  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthBias2EXT && "Function <vkCmdSetDepthBias2EXT> requires <VK_EXT_depth_bias_control>" );
20290 
20291  getDispatcher()->vkCmdSetDepthBias2EXT( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkDepthBiasInfoEXT *>( &depthBiasInfo ) );
20292  }
20293 
20294  //=== VK_EXT_acquire_drm_display ===
20295 
20296  VULKAN_HPP_INLINE void PhysicalDevice::acquireDrmDisplayEXT( int32_t drmFd, VULKAN_HPP_NAMESPACE::DisplayKHR display ) const
20297  {
20298  VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireDrmDisplayEXT && "Function <vkAcquireDrmDisplayEXT> requires <VK_EXT_acquire_drm_display>" );
20299 
20301  getDispatcher()->vkAcquireDrmDisplayEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), drmFd, static_cast<VkDisplayKHR>( display ) ) );
20302  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireDrmDisplayEXT" );
20303  }
20304 
20306  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR>::Type
20307  PhysicalDevice::getDrmDisplayEXT( int32_t drmFd, uint32_t connectorId ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT
20308  {
20309  VULKAN_HPP_NAMESPACE::DisplayKHR display;
20310  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDrmDisplayEXT(
20311  static_cast<VkPhysicalDevice>( m_physicalDevice ), drmFd, connectorId, reinterpret_cast<VkDisplayKHR *>( &display ) ) );
20312  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
20313  {
20314 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
20315  return VULKAN_HPP_UNEXPECTED( result );
20316 # else
20317  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "PhysicalDevice::getDrmDisplayEXT" );
20318 # endif
20319  }
20320 
20321  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR( *this, *reinterpret_cast<VkDisplayKHR *>( &display ) );
20322  }
20323 
20324  //=== VK_EXT_private_data ===
20325 
20327  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PrivateDataSlot>::Type
20328  Device::createPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo const & createInfo,
20329  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
20331  {
20332  VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot;
20333  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreatePrivateDataSlotEXT(
20334  static_cast<VkDevice>( m_device ),
20335  reinterpret_cast<const VkPrivateDataSlotCreateInfo *>( &createInfo ),
20336  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
20337  reinterpret_cast<VkPrivateDataSlot *>( &privateDataSlot ) ) );
20338  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
20339  {
20340 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
20341  return VULKAN_HPP_UNEXPECTED( result );
20342 # else
20343  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createPrivateDataSlotEXT" );
20344 # endif
20345  }
20346 
20347  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PrivateDataSlot( *this, *reinterpret_cast<VkPrivateDataSlot *>( &privateDataSlot ), allocator );
20348  }
20349 
20350  VULKAN_HPP_INLINE void Device::destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
20352  {
20353  VULKAN_HPP_ASSERT( getDispatcher()->vkDestroyPrivateDataSlotEXT &&
20354  "Function <vkDestroyPrivateDataSlotEXT> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" );
20355 
20356  getDispatcher()->vkDestroyPrivateDataSlotEXT(
20357  static_cast<VkDevice>( m_device ),
20358  static_cast<VkPrivateDataSlot>( privateDataSlot ),
20359  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ) );
20360  }
20361 
20362  VULKAN_HPP_INLINE void Device::setPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType_,
20363  uint64_t objectHandle,
20364  VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot,
20365  uint64_t data ) const
20366  {
20367  VULKAN_HPP_ASSERT( getDispatcher()->vkSetPrivateDataEXT && "Function <vkSetPrivateDataEXT> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" );
20368 
20369  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkSetPrivateDataEXT(
20370  static_cast<VkDevice>( m_device ), static_cast<VkObjectType>( objectType_ ), objectHandle, static_cast<VkPrivateDataSlot>( privateDataSlot ), data ) );
20371  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setPrivateDataEXT" );
20372  }
20373 
20374  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Device::getPrivateDataEXT( VULKAN_HPP_NAMESPACE::ObjectType objectType_,
20375  uint64_t objectHandle,
20376  VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot ) const VULKAN_HPP_NOEXCEPT
20377  {
20378  VULKAN_HPP_ASSERT( getDispatcher()->vkGetPrivateDataEXT && "Function <vkGetPrivateDataEXT> requires <VK_EXT_private_data> or <VK_VERSION_1_3>" );
20379 
20380  uint64_t data;
20381  getDispatcher()->vkGetPrivateDataEXT(
20382  static_cast<VkDevice>( m_device ), static_cast<VkObjectType>( objectType_ ), objectHandle, static_cast<VkPrivateDataSlot>( privateDataSlot ), &data );
20383 
20384  return data;
20385  }
20386 
20387  //=== VK_KHR_video_encode_queue ===
20388 
20389  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR(
20390  const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo ) const
20391  {
20393  "Function <vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR> requires <VK_KHR_video_encode_queue>" );
20394 
20395  VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR qualityLevelProperties;
20396  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(
20397  static_cast<VkPhysicalDevice>( m_physicalDevice ),
20398  reinterpret_cast<const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR *>( &qualityLevelInfo ),
20399  reinterpret_cast<VkVideoEncodeQualityLevelPropertiesKHR *>( &qualityLevelProperties ) ) );
20400  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR" );
20401 
20402  return qualityLevelProperties;
20403  }
20404 
20405  template <typename X, typename Y, typename... Z>
20406  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR(
20407  const VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo ) const
20408  {
20410  "Function <vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR> requires <VK_KHR_video_encode_queue>" );
20411 
20412  StructureChain<X, Y, Z...> structureChain;
20413  VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR & qualityLevelProperties =
20414  structureChain.template get<VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR>();
20415  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(
20416  static_cast<VkPhysicalDevice>( m_physicalDevice ),
20417  reinterpret_cast<const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR *>( &qualityLevelInfo ),
20418  reinterpret_cast<VkVideoEncodeQualityLevelPropertiesKHR *>( &qualityLevelProperties ) ) );
20419  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR" );
20420 
20421  return structureChain;
20422  }
20423 
20424  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR, std::vector<uint8_t>>
20425  Device::getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo ) const
20426  {
20428  "Function <vkGetEncodedVideoSessionParametersKHR> requires <VK_KHR_video_encode_queue>" );
20429 
20430  std::pair<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR, std::vector<uint8_t>> data_;
20431  VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR & feedbackInfo = data_.first;
20432  std::vector<uint8_t> & data = data_.second;
20433  size_t dataSize;
20435  do
20436  {
20437  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetEncodedVideoSessionParametersKHR(
20438  static_cast<VkDevice>( m_device ),
20439  reinterpret_cast<const VkVideoEncodeSessionParametersGetInfoKHR *>( &videoSessionParametersInfo ),
20440  reinterpret_cast<VkVideoEncodeSessionParametersFeedbackInfoKHR *>( &feedbackInfo ),
20441  &dataSize,
20442  nullptr ) );
20443  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && dataSize )
20444  {
20445  data.resize( dataSize );
20446  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetEncodedVideoSessionParametersKHR(
20447  static_cast<VkDevice>( m_device ),
20448  reinterpret_cast<const VkVideoEncodeSessionParametersGetInfoKHR *>( &videoSessionParametersInfo ),
20449  reinterpret_cast<VkVideoEncodeSessionParametersFeedbackInfoKHR *>( &feedbackInfo ),
20450  &dataSize,
20451  reinterpret_cast<void *>( data.data() ) ) );
20452  }
20453  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
20454  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getEncodedVideoSessionParametersKHR" );
20455 
20456  return data_;
20457  }
20458 
20459  template <typename X, typename Y, typename... Z>
20460  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>, std::vector<uint8_t>>
20461  Device::getEncodedVideoSessionParametersKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo ) const
20462  {
20464  "Function <vkGetEncodedVideoSessionParametersKHR> requires <VK_KHR_video_encode_queue>" );
20465 
20466  std::pair<VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>, std::vector<uint8_t>> data_;
20467  VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR & feedbackInfo =
20468  data_.first.template get<VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR>();
20469  std::vector<uint8_t> & data = data_.second;
20470  size_t dataSize;
20472  do
20473  {
20474  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetEncodedVideoSessionParametersKHR(
20475  static_cast<VkDevice>( m_device ),
20476  reinterpret_cast<const VkVideoEncodeSessionParametersGetInfoKHR *>( &videoSessionParametersInfo ),
20477  reinterpret_cast<VkVideoEncodeSessionParametersFeedbackInfoKHR *>( &feedbackInfo ),
20478  &dataSize,
20479  nullptr ) );
20480  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && dataSize )
20481  {
20482  data.resize( dataSize );
20483  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetEncodedVideoSessionParametersKHR(
20484  static_cast<VkDevice>( m_device ),
20485  reinterpret_cast<const VkVideoEncodeSessionParametersGetInfoKHR *>( &videoSessionParametersInfo ),
20486  reinterpret_cast<VkVideoEncodeSessionParametersFeedbackInfoKHR *>( &feedbackInfo ),
20487  &dataSize,
20488  reinterpret_cast<void *>( data.data() ) ) );
20489  }
20490  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
20491  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getEncodedVideoSessionParametersKHR" );
20492 
20493  return data_;
20494  }
20495 
20496  VULKAN_HPP_INLINE void CommandBuffer::encodeVideoKHR( const VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR & encodeInfo ) const VULKAN_HPP_NOEXCEPT
20497  {
20498  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEncodeVideoKHR && "Function <vkCmdEncodeVideoKHR> requires <VK_KHR_video_encode_queue>" );
20499 
20500  getDispatcher()->vkCmdEncodeVideoKHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkVideoEncodeInfoKHR *>( &encodeInfo ) );
20501  }
20502 
20503 # if defined( VK_ENABLE_BETA_EXTENSIONS )
20504  //=== VK_NV_cuda_kernel_launch ===
20505 
20507  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CudaModuleNV>::Type
20508  Device::createCudaModuleNV( VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV const & createInfo,
20509  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
20511  {
20512  VULKAN_HPP_NAMESPACE::CudaModuleNV module;
20513  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateCudaModuleNV(
20514  static_cast<VkDevice>( m_device ),
20515  reinterpret_cast<const VkCudaModuleCreateInfoNV *>( &createInfo ),
20516  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
20517  reinterpret_cast<VkCudaModuleNV *>( &module ) ) );
20518  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
20519  {
20520 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
20521  return VULKAN_HPP_UNEXPECTED( result );
20522 # else
20523  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createCudaModuleNV" );
20524 # endif
20525  }
20526 
20527  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CudaModuleNV( *this, *reinterpret_cast<VkCudaModuleNV *>( &module ), allocator );
20528  }
20529 
20530  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<uint8_t> CudaModuleNV::getCache() const
20531  {
20532  VULKAN_HPP_ASSERT( getDispatcher()->vkGetCudaModuleCacheNV && "Function <vkGetCudaModuleCacheNV> requires <VK_NV_cuda_kernel_launch>" );
20533 
20534  std::vector<uint8_t> cacheData;
20535  size_t cacheSize;
20537  do
20538  {
20539  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
20540  getDispatcher()->vkGetCudaModuleCacheNV( static_cast<VkDevice>( m_device ), static_cast<VkCudaModuleNV>( m_module ), &cacheSize, nullptr ) );
20541  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && cacheSize )
20542  {
20543  cacheData.resize( cacheSize );
20544  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetCudaModuleCacheNV(
20545  static_cast<VkDevice>( m_device ), static_cast<VkCudaModuleNV>( m_module ), &cacheSize, reinterpret_cast<void *>( cacheData.data() ) ) );
20546  }
20547  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
20548  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CudaModuleNV::getCache" );
20549  VULKAN_HPP_ASSERT( cacheSize <= cacheData.size() );
20550  if ( cacheSize < cacheData.size() )
20551  {
20552  cacheData.resize( cacheSize );
20553  }
20554  return cacheData;
20555  }
20556 
20558  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CudaFunctionNV>::Type
20559  Device::createCudaFunctionNV( VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV const & createInfo,
20560  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
20562  {
20563  VULKAN_HPP_NAMESPACE::CudaFunctionNV function;
20564  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateCudaFunctionNV(
20565  static_cast<VkDevice>( m_device ),
20566  reinterpret_cast<const VkCudaFunctionCreateInfoNV *>( &createInfo ),
20567  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
20568  reinterpret_cast<VkCudaFunctionNV *>( &function ) ) );
20569  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
20570  {
20571 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
20572  return VULKAN_HPP_UNEXPECTED( result );
20573 # else
20574  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createCudaFunctionNV" );
20575 # endif
20576  }
20577 
20578  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CudaFunctionNV( *this, *reinterpret_cast<VkCudaFunctionNV *>( &function ), allocator );
20579  }
20580 
20581  VULKAN_HPP_INLINE void CommandBuffer::cudaLaunchKernelNV( const VULKAN_HPP_NAMESPACE::CudaLaunchInfoNV & launchInfo ) const VULKAN_HPP_NOEXCEPT
20582  {
20583  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCudaLaunchKernelNV && "Function <vkCmdCudaLaunchKernelNV> requires <VK_NV_cuda_kernel_launch>" );
20584 
20585  getDispatcher()->vkCmdCudaLaunchKernelNV( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCudaLaunchInfoNV *>( &launchInfo ) );
20586  }
20587 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
20588 
20589 # if defined( VK_USE_PLATFORM_METAL_EXT )
20590  //=== VK_EXT_metal_objects ===
20591 
20592  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT Device::exportMetalObjectsEXT() const VULKAN_HPP_NOEXCEPT
20593  {
20594  VULKAN_HPP_ASSERT( getDispatcher()->vkExportMetalObjectsEXT && "Function <vkExportMetalObjectsEXT> requires <VK_EXT_metal_objects>" );
20595 
20596  VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT metalObjectsInfo;
20597  getDispatcher()->vkExportMetalObjectsEXT( static_cast<VkDevice>( m_device ), reinterpret_cast<VkExportMetalObjectsInfoEXT *>( &metalObjectsInfo ) );
20598 
20599  return metalObjectsInfo;
20600  }
20601 
20602  template <typename X, typename Y, typename... Z>
20603  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> Device::exportMetalObjectsEXT() const VULKAN_HPP_NOEXCEPT
20604  {
20605  VULKAN_HPP_ASSERT( getDispatcher()->vkExportMetalObjectsEXT && "Function <vkExportMetalObjectsEXT> requires <VK_EXT_metal_objects>" );
20606 
20607  VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
20608  VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT & metalObjectsInfo = structureChain.template get<VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT>();
20609  getDispatcher()->vkExportMetalObjectsEXT( static_cast<VkDevice>( m_device ), reinterpret_cast<VkExportMetalObjectsInfoEXT *>( &metalObjectsInfo ) );
20610 
20611  return structureChain;
20612  }
20613 # endif /*VK_USE_PLATFORM_METAL_EXT*/
20614 
20615  //=== VK_KHR_synchronization2 ===
20616 
20617  VULKAN_HPP_INLINE void CommandBuffer::setEvent2KHR( VULKAN_HPP_NAMESPACE::Event event,
20618  const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT
20619  {
20620  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetEvent2KHR && "Function <vkCmdSetEvent2KHR> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" );
20621 
20622  getDispatcher()->vkCmdSetEvent2KHR(
20623  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkEvent>( event ), reinterpret_cast<const VkDependencyInfo *>( &dependencyInfo ) );
20624  }
20625 
20626  VULKAN_HPP_INLINE void CommandBuffer::resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event event,
20628  {
20629  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdResetEvent2KHR && "Function <vkCmdResetEvent2KHR> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" );
20630 
20631  getDispatcher()->vkCmdResetEvent2KHR(
20632  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags2>( stageMask ) );
20633  }
20634 
20635  VULKAN_HPP_INLINE void
20636  CommandBuffer::waitEvents2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Event> const & events,
20637  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DependencyInfo> const & dependencyInfos ) const
20638  {
20639  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWaitEvents2KHR && "Function <vkCmdWaitEvents2KHR> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" );
20640 # ifdef VULKAN_HPP_NO_EXCEPTIONS
20641  VULKAN_HPP_ASSERT( events.size() == dependencyInfos.size() );
20642 # else
20643  if ( events.size() != dependencyInfos.size() )
20644  {
20645  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::waitEvents2KHR: events.size() != dependencyInfos.size()" );
20646  }
20647 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
20648 
20649  getDispatcher()->vkCmdWaitEvents2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
20650  events.size(),
20651  reinterpret_cast<const VkEvent *>( events.data() ),
20652  reinterpret_cast<const VkDependencyInfo *>( dependencyInfos.data() ) );
20653  }
20654 
20655  VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier2KHR( const VULKAN_HPP_NAMESPACE::DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT
20656  {
20657  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPipelineBarrier2KHR &&
20658  "Function <vkCmdPipelineBarrier2KHR> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" );
20659 
20660  getDispatcher()->vkCmdPipelineBarrier2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
20661  reinterpret_cast<const VkDependencyInfo *>( &dependencyInfo ) );
20662  }
20663 
20664  VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp2KHR( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage,
20665  VULKAN_HPP_NAMESPACE::QueryPool queryPool,
20666  uint32_t query ) const VULKAN_HPP_NOEXCEPT
20667  {
20668  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteTimestamp2KHR &&
20669  "Function <vkCmdWriteTimestamp2KHR> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" );
20670 
20671  getDispatcher()->vkCmdWriteTimestamp2KHR(
20672  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPipelineStageFlags2>( stage ), static_cast<VkQueryPool>( queryPool ), query );
20673  }
20674 
20675  VULKAN_HPP_INLINE void Queue::submit2KHR( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SubmitInfo2> const & submits,
20676  VULKAN_HPP_NAMESPACE::Fence fence ) const
20677  {
20678  VULKAN_HPP_ASSERT( getDispatcher()->vkQueueSubmit2KHR && "Function <vkQueueSubmit2KHR> requires <VK_KHR_synchronization2> or <VK_VERSION_1_3>" );
20679 
20680  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkQueueSubmit2KHR(
20681  static_cast<VkQueue>( m_queue ), submits.size(), reinterpret_cast<const VkSubmitInfo2 *>( submits.data() ), static_cast<VkFence>( fence ) ) );
20682  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::submit2KHR" );
20683  }
20684 
20685  VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarker2AMD( VULKAN_HPP_NAMESPACE::PipelineStageFlags2 stage,
20686  VULKAN_HPP_NAMESPACE::Buffer dstBuffer,
20688  uint32_t marker ) const VULKAN_HPP_NOEXCEPT
20689  {
20690  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteBufferMarker2AMD && "Function <vkCmdWriteBufferMarker2AMD> requires <VK_KHR_synchronization2>" );
20691 
20692  getDispatcher()->vkCmdWriteBufferMarker2AMD( static_cast<VkCommandBuffer>( m_commandBuffer ),
20693  static_cast<VkPipelineStageFlags2>( stage ),
20694  static_cast<VkBuffer>( dstBuffer ),
20695  static_cast<VkDeviceSize>( dstOffset ),
20696  marker );
20697  }
20698 
20699  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV> Queue::getCheckpointData2NV() const
20700  {
20701  VULKAN_HPP_ASSERT( getDispatcher()->vkGetQueueCheckpointData2NV && "Function <vkGetQueueCheckpointData2NV> requires <VK_KHR_synchronization2>" );
20702 
20703  std::vector<VULKAN_HPP_NAMESPACE::CheckpointData2NV> checkpointData;
20704  uint32_t checkpointDataCount;
20705  getDispatcher()->vkGetQueueCheckpointData2NV( static_cast<VkQueue>( m_queue ), &checkpointDataCount, nullptr );
20706  checkpointData.resize( checkpointDataCount );
20707  getDispatcher()->vkGetQueueCheckpointData2NV(
20708  static_cast<VkQueue>( m_queue ), &checkpointDataCount, reinterpret_cast<VkCheckpointData2NV *>( checkpointData.data() ) );
20709 
20710  VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() );
20711  if ( checkpointDataCount < checkpointData.size() )
20712  {
20713  checkpointData.resize( checkpointDataCount );
20714  }
20715  return checkpointData;
20716  }
20717 
20718  //=== VK_EXT_descriptor_buffer ===
20719 
20721  {
20722  VULKAN_HPP_ASSERT( getDispatcher()->vkGetDescriptorSetLayoutSizeEXT && "Function <vkGetDescriptorSetLayoutSizeEXT> requires <VK_EXT_descriptor_buffer>" );
20723 
20724  VULKAN_HPP_NAMESPACE::DeviceSize layoutSizeInBytes;
20725  getDispatcher()->vkGetDescriptorSetLayoutSizeEXT( static_cast<VkDevice>( m_device ),
20726  static_cast<VkDescriptorSetLayout>( m_descriptorSetLayout ),
20727  reinterpret_cast<VkDeviceSize *>( &layoutSizeInBytes ) );
20728 
20729  return layoutSizeInBytes;
20730  }
20731 
20733  DescriptorSetLayout::getBindingOffsetEXT( uint32_t binding ) const VULKAN_HPP_NOEXCEPT
20734  {
20736  "Function <vkGetDescriptorSetLayoutBindingOffsetEXT> requires <VK_EXT_descriptor_buffer>" );
20737 
20739  getDispatcher()->vkGetDescriptorSetLayoutBindingOffsetEXT(
20740  static_cast<VkDevice>( m_device ), static_cast<VkDescriptorSetLayout>( m_descriptorSetLayout ), binding, reinterpret_cast<VkDeviceSize *>( &offset ) );
20741 
20742  return offset;
20743  }
20744 
20745  VULKAN_HPP_INLINE void Device::getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT & descriptorInfo,
20746  size_t dataSize,
20747  void * pDescriptor ) const VULKAN_HPP_NOEXCEPT
20748  {
20749  VULKAN_HPP_ASSERT( getDispatcher()->vkGetDescriptorEXT && "Function <vkGetDescriptorEXT> requires <VK_EXT_descriptor_buffer>" );
20750 
20751  getDispatcher()->vkGetDescriptorEXT(
20752  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDescriptorGetInfoEXT *>( &descriptorInfo ), dataSize, pDescriptor );
20753  }
20754 
20755  template <typename DescriptorType>
20757  Device::getDescriptorEXT( const VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT & descriptorInfo ) const VULKAN_HPP_NOEXCEPT
20758  {
20759  VULKAN_HPP_ASSERT( getDispatcher()->vkGetDescriptorEXT && "Function <vkGetDescriptorEXT> requires <VK_EXT_descriptor_buffer>" );
20760 
20761  DescriptorType descriptor;
20762  getDispatcher()->vkGetDescriptorEXT( static_cast<VkDevice>( m_device ),
20763  reinterpret_cast<const VkDescriptorGetInfoEXT *>( &descriptorInfo ),
20764  sizeof( DescriptorType ),
20765  reinterpret_cast<void *>( &descriptor ) );
20766 
20767  return descriptor;
20768  }
20769 
20770  VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorBuffersEXT(
20771  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT> const & bindingInfos ) const VULKAN_HPP_NOEXCEPT
20772  {
20773  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindDescriptorBuffersEXT && "Function <vkCmdBindDescriptorBuffersEXT> requires <VK_EXT_descriptor_buffer>" );
20774 
20775  getDispatcher()->vkCmdBindDescriptorBuffersEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
20776  bindingInfos.size(),
20777  reinterpret_cast<const VkDescriptorBufferBindingInfoEXT *>( bindingInfos.data() ) );
20778  }
20779 
20780  VULKAN_HPP_INLINE void
20781  CommandBuffer::setDescriptorBufferOffsetsEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
20782  VULKAN_HPP_NAMESPACE::PipelineLayout layout,
20783  uint32_t firstSet,
20784  VULKAN_HPP_NAMESPACE::ArrayProxy<const uint32_t> const & bufferIndices,
20785  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DeviceSize> const & offsets ) const
20786  {
20788  "Function <vkCmdSetDescriptorBufferOffsetsEXT> requires <VK_EXT_descriptor_buffer>" );
20789 # ifdef VULKAN_HPP_NO_EXCEPTIONS
20790  VULKAN_HPP_ASSERT( bufferIndices.size() == offsets.size() );
20791 # else
20792  if ( bufferIndices.size() != offsets.size() )
20793  {
20794  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setDescriptorBufferOffsetsEXT: bufferIndices.size() != offsets.size()" );
20795  }
20796 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
20797 
20798  getDispatcher()->vkCmdSetDescriptorBufferOffsetsEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
20799  static_cast<VkPipelineBindPoint>( pipelineBindPoint ),
20800  static_cast<VkPipelineLayout>( layout ),
20801  firstSet,
20802  bufferIndices.size(),
20803  bufferIndices.data(),
20804  reinterpret_cast<const VkDeviceSize *>( offsets.data() ) );
20805  }
20806 
20807  VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorBufferEmbeddedSamplersEXT( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
20808  VULKAN_HPP_NAMESPACE::PipelineLayout layout,
20809  uint32_t set ) const VULKAN_HPP_NOEXCEPT
20810  {
20812  "Function <vkCmdBindDescriptorBufferEmbeddedSamplersEXT> requires <VK_EXT_descriptor_buffer>" );
20813 
20814  getDispatcher()->vkCmdBindDescriptorBufferEmbeddedSamplersEXT(
20815  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipelineLayout>( layout ), set );
20816  }
20817 
20818  template <typename DataType>
20820  Device::getBufferOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT & info ) const
20821  {
20823  "Function <vkGetBufferOpaqueCaptureDescriptorDataEXT> requires <VK_EXT_descriptor_buffer>" );
20824 
20825  DataType data;
20826  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetBufferOpaqueCaptureDescriptorDataEXT(
20827  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkBufferCaptureDescriptorDataInfoEXT *>( &info ), &data ) );
20828  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getBufferOpaqueCaptureDescriptorDataEXT" );
20829 
20830  return data;
20831  }
20832 
20833  template <typename DataType>
20835  Device::getImageOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT & info ) const
20836  {
20838  "Function <vkGetImageOpaqueCaptureDescriptorDataEXT> requires <VK_EXT_descriptor_buffer>" );
20839 
20840  DataType data;
20841  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetImageOpaqueCaptureDescriptorDataEXT(
20842  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImageCaptureDescriptorDataInfoEXT *>( &info ), &data ) );
20843  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageOpaqueCaptureDescriptorDataEXT" );
20844 
20845  return data;
20846  }
20847 
20848  template <typename DataType>
20850  Device::getImageViewOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT & info ) const
20851  {
20853  "Function <vkGetImageViewOpaqueCaptureDescriptorDataEXT> requires <VK_EXT_descriptor_buffer>" );
20854 
20855  DataType data;
20856  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetImageViewOpaqueCaptureDescriptorDataEXT(
20857  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImageViewCaptureDescriptorDataInfoEXT *>( &info ), &data ) );
20858  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageViewOpaqueCaptureDescriptorDataEXT" );
20859 
20860  return data;
20861  }
20862 
20863  template <typename DataType>
20865  Device::getSamplerOpaqueCaptureDescriptorDataEXT( const VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT & info ) const
20866  {
20868  "Function <vkGetSamplerOpaqueCaptureDescriptorDataEXT> requires <VK_EXT_descriptor_buffer>" );
20869 
20870  DataType data;
20871  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetSamplerOpaqueCaptureDescriptorDataEXT(
20872  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSamplerCaptureDescriptorDataInfoEXT *>( &info ), &data ) );
20873  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSamplerOpaqueCaptureDescriptorDataEXT" );
20874 
20875  return data;
20876  }
20877 
20878  template <typename DataType>
20879  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DataType Device::getAccelerationStructureOpaqueCaptureDescriptorDataEXT(
20880  const VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT & info ) const
20881  {
20883  "Function <vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT> requires <VK_EXT_descriptor_buffer>" );
20884 
20885  DataType data;
20887  static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(
20888  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkAccelerationStructureCaptureDescriptorDataInfoEXT *>( &info ), &data ) );
20889  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureOpaqueCaptureDescriptorDataEXT" );
20890 
20891  return data;
20892  }
20893 
20894  //=== VK_NV_fragment_shading_rate_enums ===
20895 
20896  VULKAN_HPP_INLINE void
20897  CommandBuffer::setFragmentShadingRateEnumNV( VULKAN_HPP_NAMESPACE::FragmentShadingRateNV shadingRate,
20899  {
20901  "Function <vkCmdSetFragmentShadingRateEnumNV> requires <VK_NV_fragment_shading_rate_enums>" );
20902 
20903  getDispatcher()->vkCmdSetFragmentShadingRateEnumNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
20904  static_cast<VkFragmentShadingRateNV>( shadingRate ),
20905  reinterpret_cast<const VkFragmentShadingRateCombinerOpKHR *>( combinerOps ) );
20906  }
20907 
20908  //=== VK_EXT_mesh_shader ===
20909 
20910  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksEXT( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
20911  {
20912  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksEXT && "Function <vkCmdDrawMeshTasksEXT> requires <VK_EXT_mesh_shader>" );
20913 
20914  getDispatcher()->vkCmdDrawMeshTasksEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), groupCountX, groupCountY, groupCountZ );
20915  }
20916 
20917  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectEXT( VULKAN_HPP_NAMESPACE::Buffer buffer,
20919  uint32_t drawCount,
20920  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
20921  {
20922  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksIndirectEXT && "Function <vkCmdDrawMeshTasksIndirectEXT> requires <VK_EXT_mesh_shader>" );
20923 
20924  getDispatcher()->vkCmdDrawMeshTasksIndirectEXT(
20925  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ), drawCount, stride );
20926  }
20927 
20928  VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountEXT( VULKAN_HPP_NAMESPACE::Buffer buffer,
20930  VULKAN_HPP_NAMESPACE::Buffer countBuffer,
20931  VULKAN_HPP_NAMESPACE::DeviceSize countBufferOffset,
20932  uint32_t maxDrawCount,
20933  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
20934  {
20935  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksIndirectCountEXT && "Function <vkCmdDrawMeshTasksIndirectCountEXT> requires <VK_EXT_mesh_shader>" );
20936 
20937  getDispatcher()->vkCmdDrawMeshTasksIndirectCountEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
20938  static_cast<VkBuffer>( buffer ),
20939  static_cast<VkDeviceSize>( offset ),
20940  static_cast<VkBuffer>( countBuffer ),
20941  static_cast<VkDeviceSize>( countBufferOffset ),
20942  maxDrawCount,
20943  stride );
20944  }
20945 
20946  //=== VK_KHR_copy_commands2 ===
20947 
20948  VULKAN_HPP_INLINE void CommandBuffer::copyBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferInfo2 & copyBufferInfo ) const VULKAN_HPP_NOEXCEPT
20949  {
20950  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyBuffer2KHR && "Function <vkCmdCopyBuffer2KHR> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" );
20951 
20952  getDispatcher()->vkCmdCopyBuffer2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCopyBufferInfo2 *>( &copyBufferInfo ) );
20953  }
20954 
20955  VULKAN_HPP_INLINE void CommandBuffer::copyImage2KHR( const VULKAN_HPP_NAMESPACE::CopyImageInfo2 & copyImageInfo ) const VULKAN_HPP_NOEXCEPT
20956  {
20957  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyImage2KHR && "Function <vkCmdCopyImage2KHR> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" );
20958 
20959  getDispatcher()->vkCmdCopyImage2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCopyImageInfo2 *>( &copyImageInfo ) );
20960  }
20961 
20962  VULKAN_HPP_INLINE void
20963  CommandBuffer::copyBufferToImage2KHR( const VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 & copyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT
20964  {
20965  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyBufferToImage2KHR &&
20966  "Function <vkCmdCopyBufferToImage2KHR> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" );
20967 
20968  getDispatcher()->vkCmdCopyBufferToImage2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
20969  reinterpret_cast<const VkCopyBufferToImageInfo2 *>( &copyBufferToImageInfo ) );
20970  }
20971 
20972  VULKAN_HPP_INLINE void
20973  CommandBuffer::copyImageToBuffer2KHR( const VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 & copyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT
20974  {
20975  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyImageToBuffer2KHR &&
20976  "Function <vkCmdCopyImageToBuffer2KHR> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" );
20977 
20978  getDispatcher()->vkCmdCopyImageToBuffer2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
20979  reinterpret_cast<const VkCopyImageToBufferInfo2 *>( &copyImageToBufferInfo ) );
20980  }
20981 
20982  VULKAN_HPP_INLINE void CommandBuffer::blitImage2KHR( const VULKAN_HPP_NAMESPACE::BlitImageInfo2 & blitImageInfo ) const VULKAN_HPP_NOEXCEPT
20983  {
20984  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBlitImage2KHR && "Function <vkCmdBlitImage2KHR> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" );
20985 
20986  getDispatcher()->vkCmdBlitImage2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkBlitImageInfo2 *>( &blitImageInfo ) );
20987  }
20988 
20989  VULKAN_HPP_INLINE void CommandBuffer::resolveImage2KHR( const VULKAN_HPP_NAMESPACE::ResolveImageInfo2 & resolveImageInfo ) const VULKAN_HPP_NOEXCEPT
20990  {
20991  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdResolveImage2KHR && "Function <vkCmdResolveImage2KHR> requires <VK_KHR_copy_commands2> or <VK_VERSION_1_3>" );
20992 
20993  getDispatcher()->vkCmdResolveImage2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
20994  reinterpret_cast<const VkResolveImageInfo2 *>( &resolveImageInfo ) );
20995  }
20996 
20997  //=== VK_EXT_device_fault ===
20998 
21000  VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, std::pair<VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT, VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT>>
21001  Device::getFaultInfoEXT() const
21002  {
21003  VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceFaultInfoEXT && "Function <vkGetDeviceFaultInfoEXT> requires <VK_EXT_device_fault>" );
21004 
21005  std::pair<VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT, VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT> data_;
21006  VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT & faultCounts = data_.first;
21007  VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT & faultInfo = data_.second;
21009  static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDeviceFaultInfoEXT( static_cast<VkDevice>( m_device ),
21010  reinterpret_cast<VkDeviceFaultCountsEXT *>( &faultCounts ),
21011  reinterpret_cast<VkDeviceFaultInfoEXT *>( &faultInfo ) ) );
21012  resultCheck( result,
21013  VULKAN_HPP_NAMESPACE_STRING "::Device::getFaultInfoEXT",
21014  { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncomplete } );
21015 
21016  return std::make_pair( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), data_ );
21017  }
21018 
21019 # if defined( VK_USE_PLATFORM_WIN32_KHR )
21020  //=== VK_NV_acquire_winrt_display ===
21021 
21022  VULKAN_HPP_INLINE void DisplayKHR::acquireWinrtNV() const
21023  {
21024  VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireWinrtDisplayNV && "Function <vkAcquireWinrtDisplayNV> requires <VK_NV_acquire_winrt_display>" );
21025 
21027  getDispatcher()->vkAcquireWinrtDisplayNV( static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkDisplayKHR>( m_display ) ) );
21028  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::DisplayKHR::acquireWinrtNV" );
21029  }
21030 
21032  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR>::Type
21033  PhysicalDevice::getWinrtDisplayNV( uint32_t deviceRelativeId ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT
21034  {
21035  VULKAN_HPP_NAMESPACE::DisplayKHR display;
21036  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetWinrtDisplayNV(
21037  static_cast<VkPhysicalDevice>( m_physicalDevice ), deviceRelativeId, reinterpret_cast<VkDisplayKHR *>( &display ) ) );
21038  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
21039  {
21040 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
21041  return VULKAN_HPP_UNEXPECTED( result );
21042 # else
21043  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "PhysicalDevice::getWinrtDisplayNV" );
21044 # endif
21045  }
21046 
21047  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR( *this, *reinterpret_cast<VkDisplayKHR *>( &display ) );
21048  }
21049 # endif /*VK_USE_PLATFORM_WIN32_KHR*/
21050 
21051 # if defined( VK_USE_PLATFORM_DIRECTFB_EXT )
21052  //=== VK_EXT_directfb_surface ===
21053 
21055  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type
21056  Instance::createDirectFBSurfaceEXT( VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT const & createInfo,
21057  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
21059  {
21060  VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
21061  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateDirectFBSurfaceEXT(
21062  static_cast<VkInstance>( m_instance ),
21063  reinterpret_cast<const VkDirectFBSurfaceCreateInfoEXT *>( &createInfo ),
21064  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
21065  reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
21066  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
21067  {
21068 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
21069  return VULKAN_HPP_UNEXPECTED( result );
21070 # else
21071  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Instance::createDirectFBSurfaceEXT" );
21072 # endif
21073  }
21074 
21075  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, *reinterpret_cast<VkSurfaceKHR *>( &surface ), allocator );
21076  }
21077 
21079  PhysicalDevice::getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex, IDirectFB & dfb ) const VULKAN_HPP_NOEXCEPT
21080  {
21081  VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceDirectFBPresentationSupportEXT &&
21082  "Function <vkGetPhysicalDeviceDirectFBPresentationSupportEXT> requires <VK_EXT_directfb_surface>" );
21083 
21084  VkBool32 result =
21085  getDispatcher()->vkGetPhysicalDeviceDirectFBPresentationSupportEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &dfb );
21086 
21087  return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( result );
21088  }
21089 # endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/
21090 
21091  //=== VK_EXT_vertex_input_dynamic_state ===
21092 
21093  VULKAN_HPP_INLINE void CommandBuffer::setVertexInputEXT(
21094  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT> const & vertexBindingDescriptions,
21095  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT> const & vertexAttributeDescriptions ) const
21097  {
21098  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetVertexInputEXT &&
21099  "Function <vkCmdSetVertexInputEXT> requires <VK_EXT_shader_object> or <VK_EXT_vertex_input_dynamic_state>" );
21100 
21101  getDispatcher()->vkCmdSetVertexInputEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
21102  vertexBindingDescriptions.size(),
21103  reinterpret_cast<const VkVertexInputBindingDescription2EXT *>( vertexBindingDescriptions.data() ),
21104  vertexAttributeDescriptions.size(),
21105  reinterpret_cast<const VkVertexInputAttributeDescription2EXT *>( vertexAttributeDescriptions.data() ) );
21106  }
21107 
21108 # if defined( VK_USE_PLATFORM_FUCHSIA )
21109  //=== VK_FUCHSIA_external_memory ===
21110 
21112  Device::getMemoryZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo ) const
21113  {
21114  VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryZirconHandleFUCHSIA && "Function <vkGetMemoryZirconHandleFUCHSIA> requires <VK_FUCHSIA_external_memory>" );
21115 
21116  zx_handle_t zirconHandle;
21117  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetMemoryZirconHandleFUCHSIA(
21118  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkMemoryGetZirconHandleInfoFUCHSIA *>( &getZirconHandleInfo ), &zirconHandle ) );
21119  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandleFUCHSIA" );
21120 
21121  return zirconHandle;
21122  }
21123 
21124  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA
21125  Device::getMemoryZirconHandlePropertiesFUCHSIA( VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle ) const
21126  {
21127  VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryZirconHandlePropertiesFUCHSIA &&
21128  "Function <vkGetMemoryZirconHandlePropertiesFUCHSIA> requires <VK_FUCHSIA_external_memory>" );
21129 
21130  VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA memoryZirconHandleProperties;
21131  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetMemoryZirconHandlePropertiesFUCHSIA(
21132  static_cast<VkDevice>( m_device ),
21133  static_cast<VkExternalMemoryHandleTypeFlagBits>( handleType ),
21134  zirconHandle,
21135  reinterpret_cast<VkMemoryZirconHandlePropertiesFUCHSIA *>( &memoryZirconHandleProperties ) ) );
21136  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandlePropertiesFUCHSIA" );
21137 
21138  return memoryZirconHandleProperties;
21139  }
21140 # endif /*VK_USE_PLATFORM_FUCHSIA*/
21141 
21142 # if defined( VK_USE_PLATFORM_FUCHSIA )
21143  //=== VK_FUCHSIA_external_semaphore ===
21144 
21145  VULKAN_HPP_INLINE void
21146  Device::importSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo ) const
21147  {
21148  VULKAN_HPP_ASSERT( getDispatcher()->vkImportSemaphoreZirconHandleFUCHSIA &&
21149  "Function <vkImportSemaphoreZirconHandleFUCHSIA> requires <VK_FUCHSIA_external_semaphore>" );
21150 
21151  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkImportSemaphoreZirconHandleFUCHSIA(
21152  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkImportSemaphoreZirconHandleInfoFUCHSIA *>( &importSemaphoreZirconHandleInfo ) ) );
21153  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreZirconHandleFUCHSIA" );
21154  }
21155 
21157  Device::getSemaphoreZirconHandleFUCHSIA( const VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo ) const
21158  {
21159  VULKAN_HPP_ASSERT( getDispatcher()->vkGetSemaphoreZirconHandleFUCHSIA &&
21160  "Function <vkGetSemaphoreZirconHandleFUCHSIA> requires <VK_FUCHSIA_external_semaphore>" );
21161 
21162  zx_handle_t zirconHandle;
21163  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetSemaphoreZirconHandleFUCHSIA(
21164  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkSemaphoreGetZirconHandleInfoFUCHSIA *>( &getZirconHandleInfo ), &zirconHandle ) );
21165  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreZirconHandleFUCHSIA" );
21166 
21167  return zirconHandle;
21168  }
21169 # endif /*VK_USE_PLATFORM_FUCHSIA*/
21170 
21171 # if defined( VK_USE_PLATFORM_FUCHSIA )
21172  //=== VK_FUCHSIA_buffer_collection ===
21173 
21175  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::BufferCollectionFUCHSIA>::Type
21176  Device::createBufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA const & createInfo,
21177  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
21179  {
21180  VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection;
21181  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateBufferCollectionFUCHSIA(
21182  static_cast<VkDevice>( m_device ),
21183  reinterpret_cast<const VkBufferCollectionCreateInfoFUCHSIA *>( &createInfo ),
21184  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
21185  reinterpret_cast<VkBufferCollectionFUCHSIA *>( &collection ) ) );
21186  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
21187  {
21188 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
21189  return VULKAN_HPP_UNEXPECTED( result );
21190 # else
21191  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createBufferCollectionFUCHSIA" );
21192 # endif
21193  }
21194 
21195  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::BufferCollectionFUCHSIA(
21196  *this, *reinterpret_cast<VkBufferCollectionFUCHSIA *>( &collection ), allocator );
21197  }
21198 
21199  VULKAN_HPP_INLINE void BufferCollectionFUCHSIA::setImageConstraints( const VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA & imageConstraintsInfo ) const
21200  {
21201  VULKAN_HPP_ASSERT( getDispatcher()->vkSetBufferCollectionImageConstraintsFUCHSIA &&
21202  "Function <vkSetBufferCollectionImageConstraintsFUCHSIA> requires <VK_FUCHSIA_buffer_collection>" );
21203 
21205  getDispatcher()->vkSetBufferCollectionImageConstraintsFUCHSIA( static_cast<VkDevice>( m_device ),
21206  static_cast<VkBufferCollectionFUCHSIA>( m_collection ),
21207  reinterpret_cast<const VkImageConstraintsInfoFUCHSIA *>( &imageConstraintsInfo ) ) );
21208  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::BufferCollectionFUCHSIA::setImageConstraints" );
21209  }
21210 
21211  VULKAN_HPP_INLINE void
21212  BufferCollectionFUCHSIA::setBufferConstraints( const VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA & bufferConstraintsInfo ) const
21213  {
21214  VULKAN_HPP_ASSERT( getDispatcher()->vkSetBufferCollectionBufferConstraintsFUCHSIA &&
21215  "Function <vkSetBufferCollectionBufferConstraintsFUCHSIA> requires <VK_FUCHSIA_buffer_collection>" );
21216 
21218  getDispatcher()->vkSetBufferCollectionBufferConstraintsFUCHSIA( static_cast<VkDevice>( m_device ),
21219  static_cast<VkBufferCollectionFUCHSIA>( m_collection ),
21220  reinterpret_cast<const VkBufferConstraintsInfoFUCHSIA *>( &bufferConstraintsInfo ) ) );
21221  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::BufferCollectionFUCHSIA::setBufferConstraints" );
21222  }
21223 
21224  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA BufferCollectionFUCHSIA::getProperties() const
21225  {
21226  VULKAN_HPP_ASSERT( getDispatcher()->vkGetBufferCollectionPropertiesFUCHSIA &&
21227  "Function <vkGetBufferCollectionPropertiesFUCHSIA> requires <VK_FUCHSIA_buffer_collection>" );
21228 
21229  VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA properties;
21231  getDispatcher()->vkGetBufferCollectionPropertiesFUCHSIA( static_cast<VkDevice>( m_device ),
21232  static_cast<VkBufferCollectionFUCHSIA>( m_collection ),
21233  reinterpret_cast<VkBufferCollectionPropertiesFUCHSIA *>( &properties ) ) );
21234  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::BufferCollectionFUCHSIA::getProperties" );
21235 
21236  return properties;
21237  }
21238 # endif /*VK_USE_PLATFORM_FUCHSIA*/
21239 
21240  //=== VK_HUAWEI_subpass_shading ===
21241 
21242  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<VULKAN_HPP_NAMESPACE::Result, VULKAN_HPP_NAMESPACE::Extent2D>
21243  RenderPass::getSubpassShadingMaxWorkgroupSizeHUAWEI() const
21244  {
21246  "Function <vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI> requires <VK_HUAWEI_subpass_shading>" );
21247 
21248  VULKAN_HPP_NAMESPACE::Extent2D maxWorkgroupSize;
21249  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(
21250  static_cast<VkDevice>( m_device ), static_cast<VkRenderPass>( m_renderPass ), reinterpret_cast<VkExtent2D *>( &maxWorkgroupSize ) ) );
21251  resultCheck( result,
21252  VULKAN_HPP_NAMESPACE_STRING "::RenderPass::getSubpassShadingMaxWorkgroupSizeHUAWEI",
21253  { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eIncomplete } );
21254 
21255  return std::make_pair( static_cast<VULKAN_HPP_NAMESPACE::Result>( result ), maxWorkgroupSize );
21256  }
21257 
21258  VULKAN_HPP_INLINE void CommandBuffer::subpassShadingHUAWEI() const VULKAN_HPP_NOEXCEPT
21259  {
21260  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSubpassShadingHUAWEI && "Function <vkCmdSubpassShadingHUAWEI> requires <VK_HUAWEI_subpass_shading>" );
21261 
21262  getDispatcher()->vkCmdSubpassShadingHUAWEI( static_cast<VkCommandBuffer>( m_commandBuffer ) );
21263  }
21264 
21265  //=== VK_HUAWEI_invocation_mask ===
21266 
21267  VULKAN_HPP_INLINE void CommandBuffer::bindInvocationMaskHUAWEI( VULKAN_HPP_NAMESPACE::ImageView imageView,
21269  {
21270  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindInvocationMaskHUAWEI && "Function <vkCmdBindInvocationMaskHUAWEI> requires <VK_HUAWEI_invocation_mask>" );
21271 
21272  getDispatcher()->vkCmdBindInvocationMaskHUAWEI(
21273  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkImageView>( imageView ), static_cast<VkImageLayout>( imageLayout ) );
21274  }
21275 
21276  //=== VK_NV_external_memory_rdma ===
21277 
21279  Device::getMemoryRemoteAddressNV( const VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV & memoryGetRemoteAddressInfo ) const
21280  {
21281  VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryRemoteAddressNV && "Function <vkGetMemoryRemoteAddressNV> requires <VK_NV_external_memory_rdma>" );
21282 
21285  getDispatcher()->vkGetMemoryRemoteAddressNV( static_cast<VkDevice>( m_device ),
21286  reinterpret_cast<const VkMemoryGetRemoteAddressInfoNV *>( &memoryGetRemoteAddressInfo ),
21287  reinterpret_cast<VkRemoteAddressNV *>( &address ) ) );
21288  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryRemoteAddressNV" );
21289 
21290  return address;
21291  }
21292 
21293  //=== VK_EXT_pipeline_properties ===
21294 
21295  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::BaseOutStructure
21296  Device::getPipelinePropertiesEXT( const VULKAN_HPP_NAMESPACE::PipelineInfoEXT & pipelineInfo ) const
21297  {
21298  VULKAN_HPP_ASSERT( getDispatcher()->vkGetPipelinePropertiesEXT && "Function <vkGetPipelinePropertiesEXT> requires <VK_EXT_pipeline_properties>" );
21299 
21300  VULKAN_HPP_NAMESPACE::BaseOutStructure pipelineProperties;
21302  getDispatcher()->vkGetPipelinePropertiesEXT( static_cast<VkDevice>( m_device ),
21303  reinterpret_cast<const VkPipelineInfoEXT *>( &pipelineInfo ),
21304  reinterpret_cast<VkBaseOutStructure *>( &pipelineProperties ) ) );
21305  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelinePropertiesEXT" );
21306 
21307  return pipelineProperties;
21308  }
21309 
21310  //=== VK_EXT_extended_dynamic_state2 ===
21311 
21312  VULKAN_HPP_INLINE void CommandBuffer::setPatchControlPointsEXT( uint32_t patchControlPoints ) const VULKAN_HPP_NOEXCEPT
21313  {
21315  "Function <vkCmdSetPatchControlPointsEXT> requires <VK_EXT_extended_dynamic_state2> or <VK_EXT_shader_object>" );
21316 
21317  getDispatcher()->vkCmdSetPatchControlPointsEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), patchControlPoints );
21318  }
21319 
21320  VULKAN_HPP_INLINE void CommandBuffer::setRasterizerDiscardEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT
21321  {
21323  getDispatcher()->vkCmdSetRasterizerDiscardEnableEXT &&
21324  "Function <vkCmdSetRasterizerDiscardEnableEXT> requires <VK_EXT_extended_dynamic_state2> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
21325 
21326  getDispatcher()->vkCmdSetRasterizerDiscardEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( rasterizerDiscardEnable ) );
21327  }
21328 
21329  VULKAN_HPP_INLINE void CommandBuffer::setDepthBiasEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT
21330  {
21331  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthBiasEnableEXT &&
21332  "Function <vkCmdSetDepthBiasEnableEXT> requires <VK_EXT_extended_dynamic_state2> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
21333 
21334  getDispatcher()->vkCmdSetDepthBiasEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthBiasEnable ) );
21335  }
21336 
21337  VULKAN_HPP_INLINE void CommandBuffer::setLogicOpEXT( VULKAN_HPP_NAMESPACE::LogicOp logicOp ) const VULKAN_HPP_NOEXCEPT
21338  {
21339  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLogicOpEXT &&
21340  "Function <vkCmdSetLogicOpEXT> requires <VK_EXT_extended_dynamic_state2> or <VK_EXT_shader_object>" );
21341 
21342  getDispatcher()->vkCmdSetLogicOpEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkLogicOp>( logicOp ) );
21343  }
21344 
21345  VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveRestartEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT
21346  {
21348  getDispatcher()->vkCmdSetPrimitiveRestartEnableEXT &&
21349  "Function <vkCmdSetPrimitiveRestartEnableEXT> requires <VK_EXT_extended_dynamic_state2> or <VK_EXT_shader_object> or <VK_VERSION_1_3>" );
21350 
21351  getDispatcher()->vkCmdSetPrimitiveRestartEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( primitiveRestartEnable ) );
21352  }
21353 
21354 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
21355  //=== VK_QNX_screen_surface ===
21356 
21358  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR>::Type
21359  Instance::createScreenSurfaceQNX( VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const & createInfo,
21360  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
21362  {
21363  VULKAN_HPP_NAMESPACE::SurfaceKHR surface;
21364  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateScreenSurfaceQNX(
21365  static_cast<VkInstance>( m_instance ),
21366  reinterpret_cast<const VkScreenSurfaceCreateInfoQNX *>( &createInfo ),
21367  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
21368  reinterpret_cast<VkSurfaceKHR *>( &surface ) ) );
21369  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
21370  {
21371 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
21372  return VULKAN_HPP_UNEXPECTED( result );
21373 # else
21374  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Instance::createScreenSurfaceQNX" );
21375 # endif
21376  }
21377 
21378  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR( *this, *reinterpret_cast<VkSurfaceKHR *>( &surface ), allocator );
21379  }
21380 
21382  PhysicalDevice::getScreenPresentationSupportQNX( uint32_t queueFamilyIndex, struct _screen_window & window ) const VULKAN_HPP_NOEXCEPT
21383  {
21384  VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceScreenPresentationSupportQNX &&
21385  "Function <vkGetPhysicalDeviceScreenPresentationSupportQNX> requires <VK_QNX_screen_surface>" );
21386 
21387  VkBool32 result =
21388  getDispatcher()->vkGetPhysicalDeviceScreenPresentationSupportQNX( static_cast<VkPhysicalDevice>( m_physicalDevice ), queueFamilyIndex, &window );
21389 
21390  return static_cast<VULKAN_HPP_NAMESPACE::Bool32>( result );
21391  }
21392 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/
21393 
21394  //=== VK_EXT_color_write_enable ===
21395 
21396  VULKAN_HPP_INLINE void CommandBuffer::setColorWriteEnableEXT(
21397  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorWriteEnables ) const VULKAN_HPP_NOEXCEPT
21398  {
21399  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetColorWriteEnableEXT && "Function <vkCmdSetColorWriteEnableEXT> requires <VK_EXT_color_write_enable>" );
21400 
21401  getDispatcher()->vkCmdSetColorWriteEnableEXT(
21402  static_cast<VkCommandBuffer>( m_commandBuffer ), colorWriteEnables.size(), reinterpret_cast<const VkBool32 *>( colorWriteEnables.data() ) );
21403  }
21404 
21405  //=== VK_KHR_ray_tracing_maintenance1 ===
21406 
21407  VULKAN_HPP_INLINE void CommandBuffer::traceRaysIndirect2KHR( VULKAN_HPP_NAMESPACE::DeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT
21408  {
21409  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdTraceRaysIndirect2KHR && "Function <vkCmdTraceRaysIndirect2KHR> requires <VK_KHR_ray_tracing_maintenance1>" );
21410 
21411  getDispatcher()->vkCmdTraceRaysIndirect2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkDeviceAddress>( indirectDeviceAddress ) );
21412  }
21413 
21414  //=== VK_EXT_multi_draw ===
21415 
21416  VULKAN_HPP_INLINE void
21417  CommandBuffer::drawMultiEXT( VULKAN_HPP_NAMESPACE::StridedArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT> const & vertexInfo,
21418  uint32_t instanceCount,
21419  uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT
21420  {
21421  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMultiEXT && "Function <vkCmdDrawMultiEXT> requires <VK_EXT_multi_draw>" );
21422 
21423  getDispatcher()->vkCmdDrawMultiEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
21424  vertexInfo.size(),
21425  reinterpret_cast<const VkMultiDrawInfoEXT *>( vertexInfo.data() ),
21426  instanceCount,
21427  firstInstance,
21428  vertexInfo.stride() );
21429  }
21430 
21431  VULKAN_HPP_INLINE void
21432  CommandBuffer::drawMultiIndexedEXT( VULKAN_HPP_NAMESPACE::StridedArrayProxy<const VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT> const & indexInfo,
21433  uint32_t instanceCount,
21434  uint32_t firstInstance,
21435  Optional<const int32_t> vertexOffset ) const VULKAN_HPP_NOEXCEPT
21436  {
21437  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMultiIndexedEXT && "Function <vkCmdDrawMultiIndexedEXT> requires <VK_EXT_multi_draw>" );
21438 
21439  getDispatcher()->vkCmdDrawMultiIndexedEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
21440  indexInfo.size(),
21441  reinterpret_cast<const VkMultiDrawIndexedInfoEXT *>( indexInfo.data() ),
21442  instanceCount,
21443  firstInstance,
21444  indexInfo.stride(),
21445  static_cast<const int32_t *>( vertexOffset ) );
21446  }
21447 
21448  //=== VK_EXT_opacity_micromap ===
21449 
21451  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::MicromapEXT>::Type
21452  Device::createMicromapEXT( VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT const & createInfo,
21453  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
21455  {
21456  VULKAN_HPP_NAMESPACE::MicromapEXT micromap;
21457  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateMicromapEXT(
21458  static_cast<VkDevice>( m_device ),
21459  reinterpret_cast<const VkMicromapCreateInfoEXT *>( &createInfo ),
21460  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
21461  reinterpret_cast<VkMicromapEXT *>( &micromap ) ) );
21462  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
21463  {
21464 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
21465  return VULKAN_HPP_UNEXPECTED( result );
21466 # else
21467  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createMicromapEXT" );
21468 # endif
21469  }
21470 
21471  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::MicromapEXT( *this, *reinterpret_cast<VkMicromapEXT *>( &micromap ), allocator );
21472  }
21473 
21474  VULKAN_HPP_INLINE void CommandBuffer::buildMicromapsEXT(
21475  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT> const & infos ) const VULKAN_HPP_NOEXCEPT
21476  {
21477  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBuildMicromapsEXT && "Function <vkCmdBuildMicromapsEXT> requires <VK_EXT_opacity_micromap>" );
21478 
21479  getDispatcher()->vkCmdBuildMicromapsEXT(
21480  static_cast<VkCommandBuffer>( m_commandBuffer ), infos.size(), reinterpret_cast<const VkMicromapBuildInfoEXT *>( infos.data() ) );
21481  }
21482 
21484  Device::buildMicromapsEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
21485  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT> const & infos ) const
21486  {
21487  VULKAN_HPP_ASSERT( getDispatcher()->vkBuildMicromapsEXT && "Function <vkBuildMicromapsEXT> requires <VK_EXT_opacity_micromap>" );
21488 
21490  static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkBuildMicromapsEXT( static_cast<VkDevice>( m_device ),
21491  static_cast<VkDeferredOperationKHR>( deferredOperation ),
21492  infos.size(),
21493  reinterpret_cast<const VkMicromapBuildInfoEXT *>( infos.data() ) ) );
21494  resultCheck( result,
21495  VULKAN_HPP_NAMESPACE_STRING "::Device::buildMicromapsEXT",
21496  { VULKAN_HPP_NAMESPACE::Result::eSuccess,
21497  VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR,
21498  VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } );
21499 
21500  return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
21501  }
21502 
21503  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Result Device::copyMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
21504  const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT & info ) const
21505  {
21506  VULKAN_HPP_ASSERT( getDispatcher()->vkCopyMicromapEXT && "Function <vkCopyMicromapEXT> requires <VK_EXT_opacity_micromap>" );
21507 
21509  static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCopyMicromapEXT( static_cast<VkDevice>( m_device ),
21510  static_cast<VkDeferredOperationKHR>( deferredOperation ),
21511  reinterpret_cast<const VkCopyMicromapInfoEXT *>( &info ) ) );
21512  resultCheck( result,
21513  VULKAN_HPP_NAMESPACE_STRING "::Device::copyMicromapEXT",
21514  { VULKAN_HPP_NAMESPACE::Result::eSuccess,
21515  VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR,
21516  VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } );
21517 
21518  return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
21519  }
21520 
21522  Device::copyMicromapToMemoryEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
21523  const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT & info ) const
21524  {
21525  VULKAN_HPP_ASSERT( getDispatcher()->vkCopyMicromapToMemoryEXT && "Function <vkCopyMicromapToMemoryEXT> requires <VK_EXT_opacity_micromap>" );
21526 
21528  getDispatcher()->vkCopyMicromapToMemoryEXT( static_cast<VkDevice>( m_device ),
21529  static_cast<VkDeferredOperationKHR>( deferredOperation ),
21530  reinterpret_cast<const VkCopyMicromapToMemoryInfoEXT *>( &info ) ) );
21531  resultCheck( result,
21532  VULKAN_HPP_NAMESPACE_STRING "::Device::copyMicromapToMemoryEXT",
21533  { VULKAN_HPP_NAMESPACE::Result::eSuccess,
21534  VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR,
21535  VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } );
21536 
21537  return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
21538  }
21539 
21541  Device::copyMemoryToMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation,
21542  const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT & info ) const
21543  {
21544  VULKAN_HPP_ASSERT( getDispatcher()->vkCopyMemoryToMicromapEXT && "Function <vkCopyMemoryToMicromapEXT> requires <VK_EXT_opacity_micromap>" );
21545 
21547  getDispatcher()->vkCopyMemoryToMicromapEXT( static_cast<VkDevice>( m_device ),
21548  static_cast<VkDeferredOperationKHR>( deferredOperation ),
21549  reinterpret_cast<const VkCopyMemoryToMicromapInfoEXT *>( &info ) ) );
21550  resultCheck( result,
21551  VULKAN_HPP_NAMESPACE_STRING "::Device::copyMemoryToMicromapEXT",
21552  { VULKAN_HPP_NAMESPACE::Result::eSuccess,
21553  VULKAN_HPP_NAMESPACE::Result::eOperationDeferredKHR,
21554  VULKAN_HPP_NAMESPACE::Result::eOperationNotDeferredKHR } );
21555 
21556  return static_cast<VULKAN_HPP_NAMESPACE::Result>( result );
21557  }
21558 
21559  template <typename DataType>
21560  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<DataType>
21561  Device::writeMicromapsPropertiesEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps,
21563  size_t dataSize,
21564  size_t stride ) const
21565  {
21566  VULKAN_HPP_ASSERT( getDispatcher()->vkWriteMicromapsPropertiesEXT && "Function <vkWriteMicromapsPropertiesEXT> requires <VK_EXT_opacity_micromap>" );
21567 
21568  VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 );
21569  std::vector<DataType> data( dataSize / sizeof( DataType ) );
21571  static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkWriteMicromapsPropertiesEXT( static_cast<VkDevice>( m_device ),
21572  micromaps.size(),
21573  reinterpret_cast<const VkMicromapEXT *>( micromaps.data() ),
21574  static_cast<VkQueryType>( queryType ),
21575  data.size() * sizeof( DataType ),
21576  reinterpret_cast<void *>( data.data() ),
21577  stride ) );
21578  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeMicromapsPropertiesEXT" );
21579 
21580  return data;
21581  }
21582 
21583  template <typename DataType>
21585  Device::writeMicromapsPropertyEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps,
21587  size_t stride ) const
21588  {
21589  VULKAN_HPP_ASSERT( getDispatcher()->vkWriteMicromapsPropertiesEXT && "Function <vkWriteMicromapsPropertiesEXT> requires <VK_EXT_opacity_micromap>" );
21590 
21591  DataType data;
21593  static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkWriteMicromapsPropertiesEXT( static_cast<VkDevice>( m_device ),
21594  micromaps.size(),
21595  reinterpret_cast<const VkMicromapEXT *>( micromaps.data() ),
21596  static_cast<VkQueryType>( queryType ),
21597  sizeof( DataType ),
21598  reinterpret_cast<void *>( &data ),
21599  stride ) );
21600  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeMicromapsPropertyEXT" );
21601 
21602  return data;
21603  }
21604 
21605  VULKAN_HPP_INLINE void CommandBuffer::copyMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT & info ) const VULKAN_HPP_NOEXCEPT
21606  {
21607  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyMicromapEXT && "Function <vkCmdCopyMicromapEXT> requires <VK_EXT_opacity_micromap>" );
21608 
21609  getDispatcher()->vkCmdCopyMicromapEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), reinterpret_cast<const VkCopyMicromapInfoEXT *>( &info ) );
21610  }
21611 
21612  VULKAN_HPP_INLINE void CommandBuffer::copyMicromapToMemoryEXT( const VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT & info ) const VULKAN_HPP_NOEXCEPT
21613  {
21614  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyMicromapToMemoryEXT && "Function <vkCmdCopyMicromapToMemoryEXT> requires <VK_EXT_opacity_micromap>" );
21615 
21616  getDispatcher()->vkCmdCopyMicromapToMemoryEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
21617  reinterpret_cast<const VkCopyMicromapToMemoryInfoEXT *>( &info ) );
21618  }
21619 
21620  VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToMicromapEXT( const VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT & info ) const VULKAN_HPP_NOEXCEPT
21621  {
21622  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyMemoryToMicromapEXT && "Function <vkCmdCopyMemoryToMicromapEXT> requires <VK_EXT_opacity_micromap>" );
21623 
21624  getDispatcher()->vkCmdCopyMemoryToMicromapEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
21625  reinterpret_cast<const VkCopyMemoryToMicromapInfoEXT *>( &info ) );
21626  }
21627 
21628  VULKAN_HPP_INLINE void
21629  CommandBuffer::writeMicromapsPropertiesEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::MicromapEXT> const & micromaps,
21631  VULKAN_HPP_NAMESPACE::QueryPool queryPool,
21632  uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT
21633  {
21635  "Function <vkCmdWriteMicromapsPropertiesEXT> requires <VK_EXT_opacity_micromap>" );
21636 
21637  getDispatcher()->vkCmdWriteMicromapsPropertiesEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
21638  micromaps.size(),
21639  reinterpret_cast<const VkMicromapEXT *>( micromaps.data() ),
21640  static_cast<VkQueryType>( queryType ),
21641  static_cast<VkQueryPool>( queryPool ),
21642  firstQuery );
21643  }
21644 
21646  Device::getMicromapCompatibilityEXT( const VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT & versionInfo ) const VULKAN_HPP_NOEXCEPT
21647  {
21649  "Function <vkGetDeviceMicromapCompatibilityEXT> requires <VK_EXT_opacity_micromap>" );
21650 
21652  getDispatcher()->vkGetDeviceMicromapCompatibilityEXT( static_cast<VkDevice>( m_device ),
21653  reinterpret_cast<const VkMicromapVersionInfoEXT *>( &versionInfo ),
21654  reinterpret_cast<VkAccelerationStructureCompatibilityKHR *>( &compatibility ) );
21655 
21656  return compatibility;
21657  }
21658 
21659  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT
21660  Device::getMicromapBuildSizesEXT( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildTypeKHR buildType,
21661  const VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT & buildInfo ) const VULKAN_HPP_NOEXCEPT
21662  {
21663  VULKAN_HPP_ASSERT( getDispatcher()->vkGetMicromapBuildSizesEXT && "Function <vkGetMicromapBuildSizesEXT> requires <VK_EXT_opacity_micromap>" );
21664 
21665  VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT sizeInfo;
21666  getDispatcher()->vkGetMicromapBuildSizesEXT( static_cast<VkDevice>( m_device ),
21667  static_cast<VkAccelerationStructureBuildTypeKHR>( buildType ),
21668  reinterpret_cast<const VkMicromapBuildInfoEXT *>( &buildInfo ),
21669  reinterpret_cast<VkMicromapBuildSizesInfoEXT *>( &sizeInfo ) );
21670 
21671  return sizeInfo;
21672  }
21673 
21674  //=== VK_HUAWEI_cluster_culling_shader ===
21675 
21676  VULKAN_HPP_INLINE void CommandBuffer::drawClusterHUAWEI( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT
21677  {
21678  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawClusterHUAWEI && "Function <vkCmdDrawClusterHUAWEI> requires <VK_HUAWEI_cluster_culling_shader>" );
21679 
21680  getDispatcher()->vkCmdDrawClusterHUAWEI( static_cast<VkCommandBuffer>( m_commandBuffer ), groupCountX, groupCountY, groupCountZ );
21681  }
21682 
21683  VULKAN_HPP_INLINE void CommandBuffer::drawClusterIndirectHUAWEI( VULKAN_HPP_NAMESPACE::Buffer buffer,
21685  {
21687  "Function <vkCmdDrawClusterIndirectHUAWEI> requires <VK_HUAWEI_cluster_culling_shader>" );
21688 
21689  getDispatcher()->vkCmdDrawClusterIndirectHUAWEI(
21690  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBuffer>( buffer ), static_cast<VkDeviceSize>( offset ) );
21691  }
21692 
21693  //=== VK_EXT_pageable_device_local_memory ===
21694 
21695  VULKAN_HPP_INLINE void DeviceMemory::setPriorityEXT( float priority ) const VULKAN_HPP_NOEXCEPT
21696  {
21697  VULKAN_HPP_ASSERT( getDispatcher()->vkSetDeviceMemoryPriorityEXT &&
21698  "Function <vkSetDeviceMemoryPriorityEXT> requires <VK_EXT_pageable_device_local_memory>" );
21699 
21700  getDispatcher()->vkSetDeviceMemoryPriorityEXT( static_cast<VkDevice>( m_device ), static_cast<VkDeviceMemory>( m_memory ), priority );
21701  }
21702 
21703  //=== VK_KHR_maintenance4 ===
21704 
21705  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2
21706  Device::getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT
21707  {
21709  "Function <vkGetDeviceBufferMemoryRequirementsKHR> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" );
21710 
21711  VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
21712  getDispatcher()->vkGetDeviceBufferMemoryRequirementsKHR( static_cast<VkDevice>( m_device ),
21713  reinterpret_cast<const VkDeviceBufferMemoryRequirements *>( &info ),
21714  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
21715 
21716  return memoryRequirements;
21717  }
21718 
21719  template <typename X, typename Y, typename... Z>
21720  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
21721  Device::getBufferMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT
21722  {
21724  "Function <vkGetDeviceBufferMemoryRequirementsKHR> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" );
21725 
21726  VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
21727  VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
21728  getDispatcher()->vkGetDeviceBufferMemoryRequirementsKHR( static_cast<VkDevice>( m_device ),
21729  reinterpret_cast<const VkDeviceBufferMemoryRequirements *>( &info ),
21730  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
21731 
21732  return structureChain;
21733  }
21734 
21735  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2
21736  Device::getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT
21737  {
21739  "Function <vkGetDeviceImageMemoryRequirementsKHR> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" );
21740 
21741  VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
21742  getDispatcher()->vkGetDeviceImageMemoryRequirementsKHR( static_cast<VkDevice>( m_device ),
21743  reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ),
21744  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
21745 
21746  return memoryRequirements;
21747  }
21748 
21749  template <typename X, typename Y, typename... Z>
21750  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
21751  Device::getImageMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT
21752  {
21754  "Function <vkGetDeviceImageMemoryRequirementsKHR> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" );
21755 
21756  VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
21757  VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
21758  getDispatcher()->vkGetDeviceImageMemoryRequirementsKHR( static_cast<VkDevice>( m_device ),
21759  reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ),
21760  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
21761 
21762  return structureChain;
21763  }
21764 
21765  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>
21766  Device::getImageSparseMemoryRequirementsKHR( const VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements & info ) const
21767  {
21769  "Function <vkGetDeviceImageSparseMemoryRequirementsKHR> requires <VK_KHR_maintenance4> or <VK_VERSION_1_3>" );
21770 
21771  std::vector<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2> sparseMemoryRequirements;
21772  uint32_t sparseMemoryRequirementCount;
21773  getDispatcher()->vkGetDeviceImageSparseMemoryRequirementsKHR(
21774  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ), &sparseMemoryRequirementCount, nullptr );
21775  sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
21776  getDispatcher()->vkGetDeviceImageSparseMemoryRequirementsKHR( static_cast<VkDevice>( m_device ),
21777  reinterpret_cast<const VkDeviceImageMemoryRequirements *>( &info ),
21778  &sparseMemoryRequirementCount,
21779  reinterpret_cast<VkSparseImageMemoryRequirements2 *>( sparseMemoryRequirements.data() ) );
21780 
21781  VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() );
21782  if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() )
21783  {
21784  sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
21785  }
21786  return sparseMemoryRequirements;
21787  }
21788 
21789  //=== VK_VALVE_descriptor_set_host_mapping ===
21790 
21791  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE Device::getDescriptorSetLayoutHostMappingInfoVALVE(
21792  const VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE & bindingReference ) const VULKAN_HPP_NOEXCEPT
21793  {
21795  "Function <vkGetDescriptorSetLayoutHostMappingInfoVALVE> requires <VK_VALVE_descriptor_set_host_mapping>" );
21796 
21797  VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE hostMapping;
21798  getDispatcher()->vkGetDescriptorSetLayoutHostMappingInfoVALVE( static_cast<VkDevice>( m_device ),
21799  reinterpret_cast<const VkDescriptorSetBindingReferenceVALVE *>( &bindingReference ),
21800  reinterpret_cast<VkDescriptorSetLayoutHostMappingInfoVALVE *>( &hostMapping ) );
21801 
21802  return hostMapping;
21803  }
21804 
21805  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE void * DescriptorSet::getHostMappingVALVE() const VULKAN_HPP_NOEXCEPT
21806  {
21808  "Function <vkGetDescriptorSetHostMappingVALVE> requires <VK_VALVE_descriptor_set_host_mapping>" );
21809 
21810  void * pData;
21811  getDispatcher()->vkGetDescriptorSetHostMappingVALVE( static_cast<VkDevice>( m_device ), static_cast<VkDescriptorSet>( m_descriptorSet ), &pData );
21812 
21813  return pData;
21814  }
21815 
21816  //=== VK_NV_copy_memory_indirect ===
21817 
21818  VULKAN_HPP_INLINE void CommandBuffer::copyMemoryIndirectNV( VULKAN_HPP_NAMESPACE::DeviceAddress copyBufferAddress,
21819  uint32_t copyCount,
21820  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
21821  {
21822  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyMemoryIndirectNV && "Function <vkCmdCopyMemoryIndirectNV> requires <VK_NV_copy_memory_indirect>" );
21823 
21824  getDispatcher()->vkCmdCopyMemoryIndirectNV(
21825  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkDeviceAddress>( copyBufferAddress ), copyCount, stride );
21826  }
21827 
21828  VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToImageIndirectNV(
21829  VULKAN_HPP_NAMESPACE::DeviceAddress copyBufferAddress,
21830  uint32_t stride,
21831  VULKAN_HPP_NAMESPACE::Image dstImage,
21832  VULKAN_HPP_NAMESPACE::ImageLayout dstImageLayout,
21833  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ImageSubresourceLayers> const & imageSubresources ) const VULKAN_HPP_NOEXCEPT
21834  {
21836  "Function <vkCmdCopyMemoryToImageIndirectNV> requires <VK_NV_copy_memory_indirect>" );
21837 
21838  getDispatcher()->vkCmdCopyMemoryToImageIndirectNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
21839  static_cast<VkDeviceAddress>( copyBufferAddress ),
21840  imageSubresources.size(),
21841  stride,
21842  static_cast<VkImage>( dstImage ),
21843  static_cast<VkImageLayout>( dstImageLayout ),
21844  reinterpret_cast<const VkImageSubresourceLayers *>( imageSubresources.data() ) );
21845  }
21846 
21847  //=== VK_NV_memory_decompression ===
21848 
21849  VULKAN_HPP_INLINE void CommandBuffer::decompressMemoryNV(
21850  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV> const & decompressMemoryRegions ) const VULKAN_HPP_NOEXCEPT
21851  {
21852  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDecompressMemoryNV && "Function <vkCmdDecompressMemoryNV> requires <VK_NV_memory_decompression>" );
21853 
21854  getDispatcher()->vkCmdDecompressMemoryNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
21855  decompressMemoryRegions.size(),
21856  reinterpret_cast<const VkDecompressMemoryRegionNV *>( decompressMemoryRegions.data() ) );
21857  }
21858 
21859  VULKAN_HPP_INLINE void CommandBuffer::decompressMemoryIndirectCountNV( VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsAddress,
21860  VULKAN_HPP_NAMESPACE::DeviceAddress indirectCommandsCountAddress,
21861  uint32_t stride ) const VULKAN_HPP_NOEXCEPT
21862  {
21864  "Function <vkCmdDecompressMemoryIndirectCountNV> requires <VK_NV_memory_decompression>" );
21865 
21866  getDispatcher()->vkCmdDecompressMemoryIndirectCountNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
21867  static_cast<VkDeviceAddress>( indirectCommandsAddress ),
21868  static_cast<VkDeviceAddress>( indirectCommandsCountAddress ),
21869  stride );
21870  }
21871 
21872  //=== VK_NV_device_generated_commands_compute ===
21873 
21874  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::MemoryRequirements2
21875  Device::getPipelineIndirectMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT
21876  {
21878  "Function <vkGetPipelineIndirectMemoryRequirementsNV> requires <VK_NV_device_generated_commands_compute>" );
21879 
21880  VULKAN_HPP_NAMESPACE::MemoryRequirements2 memoryRequirements;
21881  getDispatcher()->vkGetPipelineIndirectMemoryRequirementsNV( static_cast<VkDevice>( m_device ),
21882  reinterpret_cast<const VkComputePipelineCreateInfo *>( &createInfo ),
21883  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
21884 
21885  return memoryRequirements;
21886  }
21887 
21888  template <typename X, typename Y, typename... Z>
21889  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
21890  Device::getPipelineIndirectMemoryRequirementsNV( const VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT
21891  {
21893  "Function <vkGetPipelineIndirectMemoryRequirementsNV> requires <VK_NV_device_generated_commands_compute>" );
21894 
21895  VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
21896  VULKAN_HPP_NAMESPACE::MemoryRequirements2 & memoryRequirements = structureChain.template get<VULKAN_HPP_NAMESPACE::MemoryRequirements2>();
21897  getDispatcher()->vkGetPipelineIndirectMemoryRequirementsNV( static_cast<VkDevice>( m_device ),
21898  reinterpret_cast<const VkComputePipelineCreateInfo *>( &createInfo ),
21899  reinterpret_cast<VkMemoryRequirements2 *>( &memoryRequirements ) );
21900 
21901  return structureChain;
21902  }
21903 
21904  VULKAN_HPP_INLINE void CommandBuffer::updatePipelineIndirectBufferNV( VULKAN_HPP_NAMESPACE::PipelineBindPoint pipelineBindPoint,
21905  VULKAN_HPP_NAMESPACE::Pipeline pipeline ) const VULKAN_HPP_NOEXCEPT
21906  {
21908  "Function <vkCmdUpdatePipelineIndirectBufferNV> requires <VK_NV_device_generated_commands_compute>" );
21909 
21910  getDispatcher()->vkCmdUpdatePipelineIndirectBufferNV(
21911  static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipeline>( pipeline ) );
21912  }
21913 
21915  Device::getPipelineIndirectAddressNV( const VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV & info ) const VULKAN_HPP_NOEXCEPT
21916  {
21918  "Function <vkGetPipelineIndirectDeviceAddressNV> requires <VK_NV_device_generated_commands_compute>" );
21919 
21920  VkDeviceAddress result = getDispatcher()->vkGetPipelineIndirectDeviceAddressNV(
21921  static_cast<VkDevice>( m_device ), reinterpret_cast<const VkPipelineIndirectDeviceAddressInfoNV *>( &info ) );
21922 
21923  return static_cast<VULKAN_HPP_NAMESPACE::DeviceAddress>( result );
21924  }
21925 
21926  //=== VK_EXT_extended_dynamic_state3 ===
21927 
21928  VULKAN_HPP_INLINE void
21929  CommandBuffer::setTessellationDomainOriginEXT( VULKAN_HPP_NAMESPACE::TessellationDomainOrigin domainOrigin ) const VULKAN_HPP_NOEXCEPT
21930  {
21932  "Function <vkCmdSetTessellationDomainOriginEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
21933 
21934  getDispatcher()->vkCmdSetTessellationDomainOriginEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
21935  static_cast<VkTessellationDomainOrigin>( domainOrigin ) );
21936  }
21937 
21938  VULKAN_HPP_INLINE void CommandBuffer::setDepthClampEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClampEnable ) const VULKAN_HPP_NOEXCEPT
21939  {
21940  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthClampEnableEXT &&
21941  "Function <vkCmdSetDepthClampEnableEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
21942 
21943  getDispatcher()->vkCmdSetDepthClampEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthClampEnable ) );
21944  }
21945 
21946  VULKAN_HPP_INLINE void CommandBuffer::setPolygonModeEXT( VULKAN_HPP_NAMESPACE::PolygonMode polygonMode ) const VULKAN_HPP_NOEXCEPT
21947  {
21948  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetPolygonModeEXT &&
21949  "Function <vkCmdSetPolygonModeEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
21950 
21951  getDispatcher()->vkCmdSetPolygonModeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkPolygonMode>( polygonMode ) );
21952  }
21953 
21954  VULKAN_HPP_INLINE void CommandBuffer::setRasterizationSamplesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits rasterizationSamples ) const VULKAN_HPP_NOEXCEPT
21955  {
21957  "Function <vkCmdSetRasterizationSamplesEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
21958 
21959  getDispatcher()->vkCmdSetRasterizationSamplesEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
21960  static_cast<VkSampleCountFlagBits>( rasterizationSamples ) );
21961  }
21962 
21963  VULKAN_HPP_INLINE void CommandBuffer::setSampleMaskEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples,
21964  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::SampleMask> const & sampleMask ) const
21965  {
21966  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetSampleMaskEXT &&
21967  "Function <vkCmdSetSampleMaskEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
21968 # ifdef VULKAN_HPP_NO_EXCEPTIONS
21969  VULKAN_HPP_ASSERT( sampleMask.size() == ( static_cast<uint32_t>( samples ) + 31 ) / 32 );
21970 # else
21971  if ( sampleMask.size() != ( static_cast<uint32_t>( samples ) + 31 ) / 32 )
21972  {
21974  "::CommandBuffer::setSampleMaskEXT: sampleMask.size() != ( static_cast<uint32_t>( samples ) + 31 ) / 32" );
21975  }
21976 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
21977 
21978  getDispatcher()->vkCmdSetSampleMaskEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
21979  static_cast<VkSampleCountFlagBits>( samples ),
21980  reinterpret_cast<const VkSampleMask *>( sampleMask.data() ) );
21981  }
21982 
21983  VULKAN_HPP_INLINE void CommandBuffer::setAlphaToCoverageEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 alphaToCoverageEnable ) const VULKAN_HPP_NOEXCEPT
21984  {
21986  "Function <vkCmdSetAlphaToCoverageEnableEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
21987 
21988  getDispatcher()->vkCmdSetAlphaToCoverageEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( alphaToCoverageEnable ) );
21989  }
21990 
21991  VULKAN_HPP_INLINE void CommandBuffer::setAlphaToOneEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 alphaToOneEnable ) const VULKAN_HPP_NOEXCEPT
21992  {
21993  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetAlphaToOneEnableEXT &&
21994  "Function <vkCmdSetAlphaToOneEnableEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
21995 
21996  getDispatcher()->vkCmdSetAlphaToOneEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( alphaToOneEnable ) );
21997  }
21998 
21999  VULKAN_HPP_INLINE void CommandBuffer::setLogicOpEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 logicOpEnable ) const VULKAN_HPP_NOEXCEPT
22000  {
22001  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLogicOpEnableEXT &&
22002  "Function <vkCmdSetLogicOpEnableEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
22003 
22004  getDispatcher()->vkCmdSetLogicOpEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( logicOpEnable ) );
22005  }
22006 
22007  VULKAN_HPP_INLINE void CommandBuffer::setColorBlendEnableEXT(
22008  uint32_t firstAttachment, VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::Bool32> const & colorBlendEnables ) const VULKAN_HPP_NOEXCEPT
22009  {
22010  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetColorBlendEnableEXT &&
22011  "Function <vkCmdSetColorBlendEnableEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
22012 
22013  getDispatcher()->vkCmdSetColorBlendEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
22014  firstAttachment,
22015  colorBlendEnables.size(),
22016  reinterpret_cast<const VkBool32 *>( colorBlendEnables.data() ) );
22017  }
22018 
22019  VULKAN_HPP_INLINE void CommandBuffer::setColorBlendEquationEXT(
22020  uint32_t firstAttachment,
22021  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT> const & colorBlendEquations ) const VULKAN_HPP_NOEXCEPT
22022  {
22024  "Function <vkCmdSetColorBlendEquationEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
22025 
22026  getDispatcher()->vkCmdSetColorBlendEquationEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
22027  firstAttachment,
22028  colorBlendEquations.size(),
22029  reinterpret_cast<const VkColorBlendEquationEXT *>( colorBlendEquations.data() ) );
22030  }
22031 
22032  VULKAN_HPP_INLINE void CommandBuffer::setColorWriteMaskEXT(
22033  uint32_t firstAttachment,
22034  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorComponentFlags> const & colorWriteMasks ) const VULKAN_HPP_NOEXCEPT
22035  {
22036  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetColorWriteMaskEXT &&
22037  "Function <vkCmdSetColorWriteMaskEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
22038 
22039  getDispatcher()->vkCmdSetColorWriteMaskEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
22040  firstAttachment,
22041  colorWriteMasks.size(),
22042  reinterpret_cast<const VkColorComponentFlags *>( colorWriteMasks.data() ) );
22043  }
22044 
22045  VULKAN_HPP_INLINE void CommandBuffer::setRasterizationStreamEXT( uint32_t rasterizationStream ) const VULKAN_HPP_NOEXCEPT
22046  {
22048  "Function <vkCmdSetRasterizationStreamEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
22049 
22050  getDispatcher()->vkCmdSetRasterizationStreamEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), rasterizationStream );
22051  }
22052 
22053  VULKAN_HPP_INLINE void CommandBuffer::setConservativeRasterizationModeEXT(
22055  {
22057  "Function <vkCmdSetConservativeRasterizationModeEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
22058 
22059  getDispatcher()->vkCmdSetConservativeRasterizationModeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
22060  static_cast<VkConservativeRasterizationModeEXT>( conservativeRasterizationMode ) );
22061  }
22062 
22063  VULKAN_HPP_INLINE void CommandBuffer::setExtraPrimitiveOverestimationSizeEXT( float extraPrimitiveOverestimationSize ) const VULKAN_HPP_NOEXCEPT
22064  {
22066  "Function <vkCmdSetExtraPrimitiveOverestimationSizeEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
22067 
22068  getDispatcher()->vkCmdSetExtraPrimitiveOverestimationSizeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), extraPrimitiveOverestimationSize );
22069  }
22070 
22071  VULKAN_HPP_INLINE void CommandBuffer::setDepthClipEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClipEnable ) const VULKAN_HPP_NOEXCEPT
22072  {
22073  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthClipEnableEXT &&
22074  "Function <vkCmdSetDepthClipEnableEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
22075 
22076  getDispatcher()->vkCmdSetDepthClipEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( depthClipEnable ) );
22077  }
22078 
22079  VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 sampleLocationsEnable ) const VULKAN_HPP_NOEXCEPT
22080  {
22082  "Function <vkCmdSetSampleLocationsEnableEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
22083 
22084  getDispatcher()->vkCmdSetSampleLocationsEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( sampleLocationsEnable ) );
22085  }
22086 
22087  VULKAN_HPP_INLINE void CommandBuffer::setColorBlendAdvancedEXT(
22088  uint32_t firstAttachment,
22089  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT> const & colorBlendAdvanced ) const VULKAN_HPP_NOEXCEPT
22090  {
22092  "Function <vkCmdSetColorBlendAdvancedEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
22093 
22094  getDispatcher()->vkCmdSetColorBlendAdvancedEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
22095  firstAttachment,
22096  colorBlendAdvanced.size(),
22097  reinterpret_cast<const VkColorBlendAdvancedEXT *>( colorBlendAdvanced.data() ) );
22098  }
22099 
22100  VULKAN_HPP_INLINE void
22101  CommandBuffer::setProvokingVertexModeEXT( VULKAN_HPP_NAMESPACE::ProvokingVertexModeEXT provokingVertexMode ) const VULKAN_HPP_NOEXCEPT
22102  {
22104  "Function <vkCmdSetProvokingVertexModeEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
22105 
22106  getDispatcher()->vkCmdSetProvokingVertexModeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
22107  static_cast<VkProvokingVertexModeEXT>( provokingVertexMode ) );
22108  }
22109 
22110  VULKAN_HPP_INLINE void
22111  CommandBuffer::setLineRasterizationModeEXT( VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT lineRasterizationMode ) const VULKAN_HPP_NOEXCEPT
22112  {
22114  "Function <vkCmdSetLineRasterizationModeEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
22115 
22116  getDispatcher()->vkCmdSetLineRasterizationModeEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
22117  static_cast<VkLineRasterizationModeEXT>( lineRasterizationMode ) );
22118  }
22119 
22120  VULKAN_HPP_INLINE void CommandBuffer::setLineStippleEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stippledLineEnable ) const VULKAN_HPP_NOEXCEPT
22121  {
22122  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLineStippleEnableEXT &&
22123  "Function <vkCmdSetLineStippleEnableEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
22124 
22125  getDispatcher()->vkCmdSetLineStippleEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( stippledLineEnable ) );
22126  }
22127 
22128  VULKAN_HPP_INLINE void CommandBuffer::setDepthClipNegativeOneToOneEXT( VULKAN_HPP_NAMESPACE::Bool32 negativeOneToOne ) const VULKAN_HPP_NOEXCEPT
22129  {
22131  "Function <vkCmdSetDepthClipNegativeOneToOneEXT> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
22132 
22133  getDispatcher()->vkCmdSetDepthClipNegativeOneToOneEXT( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( negativeOneToOne ) );
22134  }
22135 
22136  VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingEnableNV( VULKAN_HPP_NAMESPACE::Bool32 viewportWScalingEnable ) const VULKAN_HPP_NOEXCEPT
22137  {
22139  "Function <vkCmdSetViewportWScalingEnableNV> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
22140 
22141  getDispatcher()->vkCmdSetViewportWScalingEnableNV( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( viewportWScalingEnable ) );
22142  }
22143 
22144  VULKAN_HPP_INLINE void CommandBuffer::setViewportSwizzleNV(
22145  uint32_t firstViewport,
22146  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV> const & viewportSwizzles ) const VULKAN_HPP_NOEXCEPT
22147  {
22148  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetViewportSwizzleNV &&
22149  "Function <vkCmdSetViewportSwizzleNV> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
22150 
22151  getDispatcher()->vkCmdSetViewportSwizzleNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
22152  firstViewport,
22153  viewportSwizzles.size(),
22154  reinterpret_cast<const VkViewportSwizzleNV *>( viewportSwizzles.data() ) );
22155  }
22156 
22157  VULKAN_HPP_INLINE void CommandBuffer::setCoverageToColorEnableNV( VULKAN_HPP_NAMESPACE::Bool32 coverageToColorEnable ) const VULKAN_HPP_NOEXCEPT
22158  {
22160  "Function <vkCmdSetCoverageToColorEnableNV> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
22161 
22162  getDispatcher()->vkCmdSetCoverageToColorEnableNV( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( coverageToColorEnable ) );
22163  }
22164 
22165  VULKAN_HPP_INLINE void CommandBuffer::setCoverageToColorLocationNV( uint32_t coverageToColorLocation ) const VULKAN_HPP_NOEXCEPT
22166  {
22168  "Function <vkCmdSetCoverageToColorLocationNV> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
22169 
22170  getDispatcher()->vkCmdSetCoverageToColorLocationNV( static_cast<VkCommandBuffer>( m_commandBuffer ), coverageToColorLocation );
22171  }
22172 
22173  VULKAN_HPP_INLINE void
22174  CommandBuffer::setCoverageModulationModeNV( VULKAN_HPP_NAMESPACE::CoverageModulationModeNV coverageModulationMode ) const VULKAN_HPP_NOEXCEPT
22175  {
22177  "Function <vkCmdSetCoverageModulationModeNV> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
22178 
22179  getDispatcher()->vkCmdSetCoverageModulationModeNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
22180  static_cast<VkCoverageModulationModeNV>( coverageModulationMode ) );
22181  }
22182 
22183  VULKAN_HPP_INLINE void
22184  CommandBuffer::setCoverageModulationTableEnableNV( VULKAN_HPP_NAMESPACE::Bool32 coverageModulationTableEnable ) const VULKAN_HPP_NOEXCEPT
22185  {
22187  "Function <vkCmdSetCoverageModulationTableEnableNV> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
22188 
22189  getDispatcher()->vkCmdSetCoverageModulationTableEnableNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
22190  static_cast<VkBool32>( coverageModulationTableEnable ) );
22191  }
22192 
22193  VULKAN_HPP_INLINE void
22194  CommandBuffer::setCoverageModulationTableNV( VULKAN_HPP_NAMESPACE::ArrayProxy<const float> const & coverageModulationTable ) const VULKAN_HPP_NOEXCEPT
22195  {
22197  "Function <vkCmdSetCoverageModulationTableNV> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
22198 
22199  getDispatcher()->vkCmdSetCoverageModulationTableNV(
22200  static_cast<VkCommandBuffer>( m_commandBuffer ), coverageModulationTable.size(), coverageModulationTable.data() );
22201  }
22202 
22203  VULKAN_HPP_INLINE void CommandBuffer::setShadingRateImageEnableNV( VULKAN_HPP_NAMESPACE::Bool32 shadingRateImageEnable ) const VULKAN_HPP_NOEXCEPT
22204  {
22206  "Function <vkCmdSetShadingRateImageEnableNV> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
22207 
22208  getDispatcher()->vkCmdSetShadingRateImageEnableNV( static_cast<VkCommandBuffer>( m_commandBuffer ), static_cast<VkBool32>( shadingRateImageEnable ) );
22209  }
22210 
22211  VULKAN_HPP_INLINE void
22212  CommandBuffer::setRepresentativeFragmentTestEnableNV( VULKAN_HPP_NAMESPACE::Bool32 representativeFragmentTestEnable ) const VULKAN_HPP_NOEXCEPT
22213  {
22215  "Function <vkCmdSetRepresentativeFragmentTestEnableNV> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
22216 
22217  getDispatcher()->vkCmdSetRepresentativeFragmentTestEnableNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
22218  static_cast<VkBool32>( representativeFragmentTestEnable ) );
22219  }
22220 
22221  VULKAN_HPP_INLINE void
22222  CommandBuffer::setCoverageReductionModeNV( VULKAN_HPP_NAMESPACE::CoverageReductionModeNV coverageReductionMode ) const VULKAN_HPP_NOEXCEPT
22223  {
22225  "Function <vkCmdSetCoverageReductionModeNV> requires <VK_EXT_extended_dynamic_state3> or <VK_EXT_shader_object>" );
22226 
22227  getDispatcher()->vkCmdSetCoverageReductionModeNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
22228  static_cast<VkCoverageReductionModeNV>( coverageReductionMode ) );
22229  }
22230 
22231  //=== VK_EXT_shader_module_identifier ===
22232 
22233  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT ShaderModule::getIdentifierEXT() const VULKAN_HPP_NOEXCEPT
22234  {
22236  "Function <vkGetShaderModuleIdentifierEXT> requires <VK_EXT_shader_module_identifier>" );
22237 
22238  VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT identifier;
22239  getDispatcher()->vkGetShaderModuleIdentifierEXT(
22240  static_cast<VkDevice>( m_device ), static_cast<VkShaderModule>( m_shaderModule ), reinterpret_cast<VkShaderModuleIdentifierEXT *>( &identifier ) );
22241 
22242  return identifier;
22243  }
22244 
22245  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT
22246  Device::getShaderModuleCreateInfoIdentifierEXT( const VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT
22247  {
22249  "Function <vkGetShaderModuleCreateInfoIdentifierEXT> requires <VK_EXT_shader_module_identifier>" );
22250 
22251  VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT identifier;
22252  getDispatcher()->vkGetShaderModuleCreateInfoIdentifierEXT( static_cast<VkDevice>( m_device ),
22253  reinterpret_cast<const VkShaderModuleCreateInfo *>( &createInfo ),
22254  reinterpret_cast<VkShaderModuleIdentifierEXT *>( &identifier ) );
22255 
22256  return identifier;
22257  }
22258 
22259  //=== VK_NV_optical_flow ===
22260 
22261  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV>
22262  PhysicalDevice::getOpticalFlowImageFormatsNV( const VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo ) const
22263  {
22265  "Function <vkGetPhysicalDeviceOpticalFlowImageFormatsNV> requires <VK_NV_optical_flow>" );
22266 
22267  std::vector<VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV> imageFormatProperties;
22268  uint32_t formatCount;
22270  do
22271  {
22272  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceOpticalFlowImageFormatsNV(
22273  static_cast<VkPhysicalDevice>( m_physicalDevice ),
22274  reinterpret_cast<const VkOpticalFlowImageFormatInfoNV *>( &opticalFlowImageFormatInfo ),
22275  &formatCount,
22276  nullptr ) );
22277  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && formatCount )
22278  {
22279  imageFormatProperties.resize( formatCount );
22280  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceOpticalFlowImageFormatsNV(
22281  static_cast<VkPhysicalDevice>( m_physicalDevice ),
22282  reinterpret_cast<const VkOpticalFlowImageFormatInfoNV *>( &opticalFlowImageFormatInfo ),
22283  &formatCount,
22284  reinterpret_cast<VkOpticalFlowImageFormatPropertiesNV *>( imageFormatProperties.data() ) ) );
22285  }
22286  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
22287  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getOpticalFlowImageFormatsNV" );
22288  VULKAN_HPP_ASSERT( formatCount <= imageFormatProperties.size() );
22289  if ( formatCount < imageFormatProperties.size() )
22290  {
22291  imageFormatProperties.resize( formatCount );
22292  }
22293  return imageFormatProperties;
22294  }
22295 
22297  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::OpticalFlowSessionNV>::Type
22298  Device::createOpticalFlowSessionNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV const & createInfo,
22299  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
22301  {
22302  VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session;
22303  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateOpticalFlowSessionNV(
22304  static_cast<VkDevice>( m_device ),
22305  reinterpret_cast<const VkOpticalFlowSessionCreateInfoNV *>( &createInfo ),
22306  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
22307  reinterpret_cast<VkOpticalFlowSessionNV *>( &session ) ) );
22308  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
22309  {
22310 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
22311  return VULKAN_HPP_UNEXPECTED( result );
22312 # else
22313  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createOpticalFlowSessionNV" );
22314 # endif
22315  }
22316 
22317  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::OpticalFlowSessionNV( *this, *reinterpret_cast<VkOpticalFlowSessionNV *>( &session ), allocator );
22318  }
22319 
22320  VULKAN_HPP_INLINE void OpticalFlowSessionNV::bindImage( VULKAN_HPP_NAMESPACE::OpticalFlowSessionBindingPointNV bindingPoint,
22321  VULKAN_HPP_NAMESPACE::ImageView view,
22322  VULKAN_HPP_NAMESPACE::ImageLayout layout ) const
22323  {
22324  VULKAN_HPP_ASSERT( getDispatcher()->vkBindOpticalFlowSessionImageNV && "Function <vkBindOpticalFlowSessionImageNV> requires <VK_NV_optical_flow>" );
22325 
22327  getDispatcher()->vkBindOpticalFlowSessionImageNV( static_cast<VkDevice>( m_device ),
22328  static_cast<VkOpticalFlowSessionNV>( m_session ),
22329  static_cast<VkOpticalFlowSessionBindingPointNV>( bindingPoint ),
22330  static_cast<VkImageView>( view ),
22331  static_cast<VkImageLayout>( layout ) ) );
22332  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::OpticalFlowSessionNV::bindImage" );
22333  }
22334 
22335  VULKAN_HPP_INLINE void CommandBuffer::opticalFlowExecuteNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session,
22336  const VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV & executeInfo ) const VULKAN_HPP_NOEXCEPT
22337  {
22338  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdOpticalFlowExecuteNV && "Function <vkCmdOpticalFlowExecuteNV> requires <VK_NV_optical_flow>" );
22339 
22340  getDispatcher()->vkCmdOpticalFlowExecuteNV( static_cast<VkCommandBuffer>( m_commandBuffer ),
22341  static_cast<VkOpticalFlowSessionNV>( session ),
22342  reinterpret_cast<const VkOpticalFlowExecuteInfoNV *>( &executeInfo ) );
22343  }
22344 
22345  //=== VK_KHR_maintenance5 ===
22346 
22347  VULKAN_HPP_INLINE void CommandBuffer::bindIndexBuffer2KHR( VULKAN_HPP_NAMESPACE::Buffer buffer,
22351  {
22352  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindIndexBuffer2KHR && "Function <vkCmdBindIndexBuffer2KHR> requires <VK_KHR_maintenance5>" );
22353 
22354  getDispatcher()->vkCmdBindIndexBuffer2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
22355  static_cast<VkBuffer>( buffer ),
22356  static_cast<VkDeviceSize>( offset ),
22357  static_cast<VkDeviceSize>( size ),
22358  static_cast<VkIndexType>( indexType ) );
22359  }
22360 
22361  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::Extent2D
22362  Device::getRenderingAreaGranularityKHR( const VULKAN_HPP_NAMESPACE::RenderingAreaInfoKHR & renderingAreaInfo ) const VULKAN_HPP_NOEXCEPT
22363  {
22364  VULKAN_HPP_ASSERT( getDispatcher()->vkGetRenderingAreaGranularityKHR && "Function <vkGetRenderingAreaGranularityKHR> requires <VK_KHR_maintenance5>" );
22365 
22366  VULKAN_HPP_NAMESPACE::Extent2D granularity;
22367  getDispatcher()->vkGetRenderingAreaGranularityKHR( static_cast<VkDevice>( m_device ),
22368  reinterpret_cast<const VkRenderingAreaInfoKHR *>( &renderingAreaInfo ),
22369  reinterpret_cast<VkExtent2D *>( &granularity ) );
22370 
22371  return granularity;
22372  }
22373 
22374  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR
22375  Device::getImageSubresourceLayoutKHR( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfoKHR & info ) const VULKAN_HPP_NOEXCEPT
22376  {
22378  "Function <vkGetDeviceImageSubresourceLayoutKHR> requires <VK_KHR_maintenance5>" );
22379 
22380  VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR layout;
22381  getDispatcher()->vkGetDeviceImageSubresourceLayoutKHR( static_cast<VkDevice>( m_device ),
22382  reinterpret_cast<const VkDeviceImageSubresourceInfoKHR *>( &info ),
22383  reinterpret_cast<VkSubresourceLayout2KHR *>( &layout ) );
22384 
22385  return layout;
22386  }
22387 
22388  template <typename X, typename Y, typename... Z>
22389  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
22390  Device::getImageSubresourceLayoutKHR( const VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfoKHR & info ) const VULKAN_HPP_NOEXCEPT
22391  {
22393  "Function <vkGetDeviceImageSubresourceLayoutKHR> requires <VK_KHR_maintenance5>" );
22394 
22395  VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
22396  VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR & layout = structureChain.template get<VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR>();
22397  getDispatcher()->vkGetDeviceImageSubresourceLayoutKHR( static_cast<VkDevice>( m_device ),
22398  reinterpret_cast<const VkDeviceImageSubresourceInfoKHR *>( &info ),
22399  reinterpret_cast<VkSubresourceLayout2KHR *>( &layout ) );
22400 
22401  return structureChain;
22402  }
22403 
22404  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR
22405  Image::getSubresourceLayout2KHR( const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR & subresource ) const VULKAN_HPP_NOEXCEPT
22406  {
22408  getDispatcher()->vkGetImageSubresourceLayout2KHR &&
22409  "Function <vkGetImageSubresourceLayout2KHR> requires <VK_EXT_host_image_copy> or <VK_EXT_image_compression_control> or <VK_KHR_maintenance5>" );
22410 
22411  VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR layout;
22412  getDispatcher()->vkGetImageSubresourceLayout2KHR( static_cast<VkDevice>( m_device ),
22413  static_cast<VkImage>( m_image ),
22414  reinterpret_cast<const VkImageSubresource2KHR *>( &subresource ),
22415  reinterpret_cast<VkSubresourceLayout2KHR *>( &layout ) );
22416 
22417  return layout;
22418  }
22419 
22420  template <typename X, typename Y, typename... Z>
22421  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
22422  Image::getSubresourceLayout2KHR( const VULKAN_HPP_NAMESPACE::ImageSubresource2KHR & subresource ) const VULKAN_HPP_NOEXCEPT
22423  {
22425  getDispatcher()->vkGetImageSubresourceLayout2KHR &&
22426  "Function <vkGetImageSubresourceLayout2KHR> requires <VK_EXT_host_image_copy> or <VK_EXT_image_compression_control> or <VK_KHR_maintenance5>" );
22427 
22428  VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...> structureChain;
22429  VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR & layout = structureChain.template get<VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR>();
22430  getDispatcher()->vkGetImageSubresourceLayout2KHR( static_cast<VkDevice>( m_device ),
22431  static_cast<VkImage>( m_image ),
22432  reinterpret_cast<const VkImageSubresource2KHR *>( &subresource ),
22433  reinterpret_cast<VkSubresourceLayout2KHR *>( &layout ) );
22434 
22435  return structureChain;
22436  }
22437 
22438  //=== VK_EXT_shader_object ===
22439 
22441  VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ShaderEXT>>::Type
22442  Device::createShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT> const & createInfos,
22443  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const
22444  {
22445  std::vector<VULKAN_HPP_NAMESPACE::ShaderEXT> shaders( createInfos.size() );
22446  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateShadersEXT(
22447  static_cast<VkDevice>( m_device ),
22448  createInfos.size(),
22449  reinterpret_cast<const VkShaderCreateInfoEXT *>( createInfos.data() ),
22450  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
22451  reinterpret_cast<VkShaderEXT *>( shaders.data() ) ) );
22452  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
22453  {
22454 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
22455  return VULKAN_HPP_UNEXPECTED( result );
22456 # else
22457  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createShadersEXT" );
22458 # endif
22459  }
22460 
22461  std::vector<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ShaderEXT> shadersRAII;
22462  shadersRAII.reserve( shaders.size() );
22463  for ( auto & shader : shaders )
22464  {
22465  shadersRAII.emplace_back( *this, *reinterpret_cast<VkShaderEXT *>( &shader ), allocator );
22466  }
22467  return shadersRAII;
22468  }
22469 
22471  VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CreateReturnType<VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ShaderEXT>::Type
22472  Device::createShaderEXT( VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT const & createInfo,
22473  VULKAN_HPP_NAMESPACE::Optional<const VULKAN_HPP_NAMESPACE::AllocationCallbacks> allocator ) const VULKAN_HPP_RAII_CREATE_NOEXCEPT
22474  {
22475  VULKAN_HPP_NAMESPACE::ShaderEXT shader;
22476  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkCreateShadersEXT(
22477  static_cast<VkDevice>( m_device ),
22478  1,
22479  reinterpret_cast<const VkShaderCreateInfoEXT *>( &createInfo ),
22480  reinterpret_cast<const VkAllocationCallbacks *>( static_cast<const VULKAN_HPP_NAMESPACE::AllocationCallbacks *>( allocator ) ),
22481  reinterpret_cast<VkShaderEXT *>( &shader ) ) );
22482  if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess )
22483  {
22484 # if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS )
22485  return VULKAN_HPP_UNEXPECTED( result );
22486 # else
22487  VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createShaderEXT" );
22488 # endif
22489  }
22490 
22491  return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ShaderEXT( *this, *reinterpret_cast<VkShaderEXT *>( &shader ), allocator );
22492  }
22493 
22494  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<uint8_t> ShaderEXT::getBinaryData() const
22495  {
22496  VULKAN_HPP_ASSERT( getDispatcher()->vkGetShaderBinaryDataEXT && "Function <vkGetShaderBinaryDataEXT> requires <VK_EXT_shader_object>" );
22497 
22498  std::vector<uint8_t> data;
22499  size_t dataSize;
22501  do
22502  {
22503  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
22504  getDispatcher()->vkGetShaderBinaryDataEXT( static_cast<VkDevice>( m_device ), static_cast<VkShaderEXT>( m_shader ), &dataSize, nullptr ) );
22505  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && dataSize )
22506  {
22507  data.resize( dataSize );
22508  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetShaderBinaryDataEXT(
22509  static_cast<VkDevice>( m_device ), static_cast<VkShaderEXT>( m_shader ), &dataSize, reinterpret_cast<void *>( data.data() ) ) );
22510  }
22511  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
22512  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::ShaderEXT::getBinaryData" );
22513  VULKAN_HPP_ASSERT( dataSize <= data.size() );
22514  if ( dataSize < data.size() )
22515  {
22516  data.resize( dataSize );
22517  }
22518  return data;
22519  }
22520 
22521  VULKAN_HPP_INLINE void CommandBuffer::bindShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderStageFlagBits> const & stages,
22522  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::ShaderEXT> const & shaders ) const
22523  {
22524  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindShadersEXT && "Function <vkCmdBindShadersEXT> requires <VK_EXT_shader_object>" );
22525 # ifdef VULKAN_HPP_NO_EXCEPTIONS
22526  VULKAN_HPP_ASSERT( stages.size() == shaders.size() );
22527 # else
22528  if ( stages.size() != shaders.size() )
22529  {
22530  throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindShadersEXT: stages.size() != shaders.size()" );
22531  }
22532 # endif /*VULKAN_HPP_NO_EXCEPTIONS*/
22533 
22534  getDispatcher()->vkCmdBindShadersEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
22535  stages.size(),
22536  reinterpret_cast<const VkShaderStageFlagBits *>( stages.data() ),
22537  reinterpret_cast<const VkShaderEXT *>( shaders.data() ) );
22538  }
22539 
22540  //=== VK_QCOM_tile_properties ===
22541 
22542  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM> Framebuffer::getTilePropertiesQCOM() const
22543  {
22545  "Function <vkGetFramebufferTilePropertiesQCOM> requires <VK_QCOM_tile_properties>" );
22546 
22547  std::vector<VULKAN_HPP_NAMESPACE::TilePropertiesQCOM> properties;
22548  uint32_t propertiesCount;
22550  do
22551  {
22552  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetFramebufferTilePropertiesQCOM(
22553  static_cast<VkDevice>( m_device ), static_cast<VkFramebuffer>( m_framebuffer ), &propertiesCount, nullptr ) );
22554  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertiesCount )
22555  {
22556  properties.resize( propertiesCount );
22557  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
22558  getDispatcher()->vkGetFramebufferTilePropertiesQCOM( static_cast<VkDevice>( m_device ),
22559  static_cast<VkFramebuffer>( m_framebuffer ),
22560  &propertiesCount,
22561  reinterpret_cast<VkTilePropertiesQCOM *>( properties.data() ) ) );
22562  }
22563  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
22564 
22565  VULKAN_HPP_ASSERT( propertiesCount <= properties.size() );
22566  if ( propertiesCount < properties.size() )
22567  {
22568  properties.resize( propertiesCount );
22569  }
22570  return properties;
22571  }
22572 
22573  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::TilePropertiesQCOM
22574  Device::getDynamicRenderingTilePropertiesQCOM( const VULKAN_HPP_NAMESPACE::RenderingInfo & renderingInfo ) const VULKAN_HPP_NOEXCEPT
22575  {
22577  "Function <vkGetDynamicRenderingTilePropertiesQCOM> requires <VK_QCOM_tile_properties>" );
22578 
22579  VULKAN_HPP_NAMESPACE::TilePropertiesQCOM properties;
22580  getDispatcher()->vkGetDynamicRenderingTilePropertiesQCOM( static_cast<VkDevice>( m_device ),
22581  reinterpret_cast<const VkRenderingInfo *>( &renderingInfo ),
22582  reinterpret_cast<VkTilePropertiesQCOM *>( &properties ) );
22583 
22584  return properties;
22585  }
22586 
22587  //=== VK_NV_low_latency2 ===
22588 
22589  VULKAN_HPP_INLINE void SwapchainKHR::setLatencySleepModeNV( const VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV & sleepModeInfo ) const
22590  {
22591  VULKAN_HPP_ASSERT( getDispatcher()->vkSetLatencySleepModeNV && "Function <vkSetLatencySleepModeNV> requires <VK_NV_low_latency2>" );
22592 
22593  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkSetLatencySleepModeNV(
22594  static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), reinterpret_cast<const VkLatencySleepModeInfoNV *>( &sleepModeInfo ) ) );
22595  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::setLatencySleepModeNV" );
22596  }
22597 
22598  VULKAN_HPP_INLINE void SwapchainKHR::latencySleepNV( const VULKAN_HPP_NAMESPACE::LatencySleepInfoNV & sleepInfo ) const
22599  {
22600  VULKAN_HPP_ASSERT( getDispatcher()->vkLatencySleepNV && "Function <vkLatencySleepNV> requires <VK_NV_low_latency2>" );
22601 
22602  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkLatencySleepNV(
22603  static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), reinterpret_cast<const VkLatencySleepInfoNV *>( &sleepInfo ) ) );
22604  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::latencySleepNV" );
22605  }
22606 
22607  VULKAN_HPP_INLINE void SwapchainKHR::setLatencyMarkerNV( const VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV & latencyMarkerInfo ) const VULKAN_HPP_NOEXCEPT
22608  {
22609  VULKAN_HPP_ASSERT( getDispatcher()->vkSetLatencyMarkerNV && "Function <vkSetLatencyMarkerNV> requires <VK_NV_low_latency2>" );
22610 
22611  getDispatcher()->vkSetLatencyMarkerNV( static_cast<VkDevice>( m_device ),
22612  static_cast<VkSwapchainKHR>( m_swapchain ),
22613  reinterpret_cast<const VkSetLatencyMarkerInfoNV *>( &latencyMarkerInfo ) );
22614  }
22615 
22616  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV SwapchainKHR::getLatencyTimingsNV() const VULKAN_HPP_NOEXCEPT
22617  {
22618  VULKAN_HPP_ASSERT( getDispatcher()->vkGetLatencyTimingsNV && "Function <vkGetLatencyTimingsNV> requires <VK_NV_low_latency2>" );
22619 
22620  VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV latencyMarkerInfo;
22621  getDispatcher()->vkGetLatencyTimingsNV(
22622  static_cast<VkDevice>( m_device ), static_cast<VkSwapchainKHR>( m_swapchain ), reinterpret_cast<VkGetLatencyMarkerInfoNV *>( &latencyMarkerInfo ) );
22623 
22624  return latencyMarkerInfo;
22625  }
22626 
22627  VULKAN_HPP_INLINE void Queue::notifyOutOfBandNV( const VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV & queueTypeInfo ) const VULKAN_HPP_NOEXCEPT
22628  {
22629  VULKAN_HPP_ASSERT( getDispatcher()->vkQueueNotifyOutOfBandNV && "Function <vkQueueNotifyOutOfBandNV> requires <VK_NV_low_latency2>" );
22630 
22631  getDispatcher()->vkQueueNotifyOutOfBandNV( static_cast<VkQueue>( m_queue ), reinterpret_cast<const VkOutOfBandQueueTypeInfoNV *>( &queueTypeInfo ) );
22632  }
22633 
22634  //=== VK_KHR_cooperative_matrix ===
22635 
22636  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR>
22637  PhysicalDevice::getCooperativeMatrixPropertiesKHR() const
22638  {
22640  "Function <vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR> requires <VK_KHR_cooperative_matrix>" );
22641 
22642  std::vector<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR> properties;
22643  uint32_t propertyCount;
22645  do
22646  {
22647  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
22648  getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, nullptr ) );
22649  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount )
22650  {
22651  properties.resize( propertyCount );
22652  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(
22653  static_cast<VkPhysicalDevice>( m_physicalDevice ), &propertyCount, reinterpret_cast<VkCooperativeMatrixPropertiesKHR *>( properties.data() ) ) );
22654  }
22655  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
22656  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixPropertiesKHR" );
22657  VULKAN_HPP_ASSERT( propertyCount <= properties.size() );
22658  if ( propertyCount < properties.size() )
22659  {
22660  properties.resize( propertyCount );
22661  }
22662  return properties;
22663  }
22664 
22665  //=== VK_EXT_attachment_feedback_loop_dynamic_state ===
22666 
22667  VULKAN_HPP_INLINE void CommandBuffer::setAttachmentFeedbackLoopEnableEXT( VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask ) const VULKAN_HPP_NOEXCEPT
22668  {
22670  "Function <vkCmdSetAttachmentFeedbackLoopEnableEXT> requires <VK_EXT_attachment_feedback_loop_dynamic_state>" );
22671 
22672  getDispatcher()->vkCmdSetAttachmentFeedbackLoopEnableEXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
22673  static_cast<VkImageAspectFlags>( aspectMask ) );
22674  }
22675 
22676 # if defined( VK_USE_PLATFORM_SCREEN_QNX )
22677  //=== VK_QNX_external_memory_screen_buffer ===
22678 
22679  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX
22680  Device::getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer ) const
22681  {
22682  VULKAN_HPP_ASSERT( getDispatcher()->vkGetScreenBufferPropertiesQNX &&
22683  "Function <vkGetScreenBufferPropertiesQNX> requires <VK_QNX_external_memory_screen_buffer>" );
22684 
22685  VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX properties;
22686  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetScreenBufferPropertiesQNX(
22687  static_cast<VkDevice>( m_device ), &buffer, reinterpret_cast<VkScreenBufferPropertiesQNX *>( &properties ) ) );
22688  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getScreenBufferPropertiesQNX" );
22689 
22690  return properties;
22691  }
22692 
22693  template <typename X, typename Y, typename... Z>
22694  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_NAMESPACE::StructureChain<X, Y, Z...>
22695  Device::getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer ) const
22696  {
22697  VULKAN_HPP_ASSERT( getDispatcher()->vkGetScreenBufferPropertiesQNX &&
22698  "Function <vkGetScreenBufferPropertiesQNX> requires <VK_QNX_external_memory_screen_buffer>" );
22699 
22700  StructureChain<X, Y, Z...> structureChain;
22701  VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX & properties = structureChain.template get<VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX>();
22702  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetScreenBufferPropertiesQNX(
22703  static_cast<VkDevice>( m_device ), &buffer, reinterpret_cast<VkScreenBufferPropertiesQNX *>( &properties ) ) );
22704  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getScreenBufferPropertiesQNX" );
22705 
22706  return structureChain;
22707  }
22708 # endif /*VK_USE_PLATFORM_SCREEN_QNX*/
22709 
22710  //=== VK_KHR_calibrated_timestamps ===
22711 
22712  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR> PhysicalDevice::getCalibrateableTimeDomainsKHR() const
22713  {
22716  "Function <vkGetPhysicalDeviceCalibrateableTimeDomainsKHR> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
22717 
22718  std::vector<VULKAN_HPP_NAMESPACE::TimeDomainKHR> timeDomains;
22719  uint32_t timeDomainCount;
22721  do
22722  {
22723  result = static_cast<VULKAN_HPP_NAMESPACE::Result>(
22724  getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( static_cast<VkPhysicalDevice>( m_physicalDevice ), &timeDomainCount, nullptr ) );
22725  if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && timeDomainCount )
22726  {
22727  timeDomains.resize( timeDomainCount );
22728  result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(
22729  static_cast<VkPhysicalDevice>( m_physicalDevice ), &timeDomainCount, reinterpret_cast<VkTimeDomainKHR *>( timeDomains.data() ) ) );
22730  }
22731  } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete );
22732  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsKHR" );
22733  VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() );
22734  if ( timeDomainCount < timeDomains.size() )
22735  {
22736  timeDomains.resize( timeDomainCount );
22737  }
22738  return timeDomains;
22739  }
22740 
22741  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<std::vector<uint64_t>, uint64_t> Device::getCalibratedTimestampsKHR(
22742  VULKAN_HPP_NAMESPACE::ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR> const & timestampInfos ) const
22743  {
22744  VULKAN_HPP_ASSERT( getDispatcher()->vkGetCalibratedTimestampsKHR &&
22745  "Function <vkGetCalibratedTimestampsKHR> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
22746 
22747  std::pair<std::vector<uint64_t>, uint64_t> data_( std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) );
22748  std::vector<uint64_t> & timestamps = data_.first;
22749  uint64_t & maxDeviation = data_.second;
22751  getDispatcher()->vkGetCalibratedTimestampsKHR( static_cast<VkDevice>( m_device ),
22752  timestampInfos.size(),
22753  reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( timestampInfos.data() ),
22754  timestamps.data(),
22755  &maxDeviation ) );
22756  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsKHR" );
22757 
22758  return data_;
22759  }
22760 
22761  VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair<uint64_t, uint64_t>
22762  Device::getCalibratedTimestampKHR( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR & timestampInfo ) const
22763  {
22764  VULKAN_HPP_ASSERT( getDispatcher()->vkGetCalibratedTimestampsKHR &&
22765  "Function <vkGetCalibratedTimestampsKHR> requires <VK_EXT_calibrated_timestamps> or <VK_KHR_calibrated_timestamps>" );
22766 
22767  std::pair<uint64_t, uint64_t> data_;
22768  uint64_t & timestamp = data_.first;
22769  uint64_t & maxDeviation = data_.second;
22770  VULKAN_HPP_NAMESPACE::Result result = static_cast<VULKAN_HPP_NAMESPACE::Result>( getDispatcher()->vkGetCalibratedTimestampsKHR(
22771  static_cast<VkDevice>( m_device ), 1, reinterpret_cast<const VkCalibratedTimestampInfoKHR *>( &timestampInfo ), &timestamp, &maxDeviation ) );
22772  resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampKHR" );
22773 
22774  return data_;
22775  }
22776 
22777  //=== VK_KHR_maintenance6 ===
22778 
22779  VULKAN_HPP_INLINE void
22780  CommandBuffer::bindDescriptorSets2KHR( const VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfoKHR & bindDescriptorSetsInfo ) const VULKAN_HPP_NOEXCEPT
22781  {
22782  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindDescriptorSets2KHR && "Function <vkCmdBindDescriptorSets2KHR> requires <VK_KHR_maintenance6>" );
22783 
22784  getDispatcher()->vkCmdBindDescriptorSets2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
22785  reinterpret_cast<const VkBindDescriptorSetsInfoKHR *>( &bindDescriptorSetsInfo ) );
22786  }
22787 
22788  VULKAN_HPP_INLINE void CommandBuffer::pushConstants2KHR( const VULKAN_HPP_NAMESPACE::PushConstantsInfoKHR & pushConstantsInfo ) const VULKAN_HPP_NOEXCEPT
22789  {
22790  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushConstants2KHR && "Function <vkCmdPushConstants2KHR> requires <VK_KHR_maintenance6>" );
22791 
22792  getDispatcher()->vkCmdPushConstants2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
22793  reinterpret_cast<const VkPushConstantsInfoKHR *>( &pushConstantsInfo ) );
22794  }
22795 
22796  VULKAN_HPP_INLINE void
22797  CommandBuffer::pushDescriptorSet2KHR( const VULKAN_HPP_NAMESPACE::PushDescriptorSetInfoKHR & pushDescriptorSetInfo ) const VULKAN_HPP_NOEXCEPT
22798  {
22799  VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushDescriptorSet2KHR && "Function <vkCmdPushDescriptorSet2KHR> requires <VK_KHR_maintenance6>" );
22800 
22801  getDispatcher()->vkCmdPushDescriptorSet2KHR( static_cast<VkCommandBuffer>( m_commandBuffer ),
22802  reinterpret_cast<const VkPushDescriptorSetInfoKHR *>( &pushDescriptorSetInfo ) );
22803  }
22804 
22805  VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplate2KHR(
22806  const VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfoKHR & pushDescriptorSetWithTemplateInfo ) const VULKAN_HPP_NOEXCEPT
22807  {
22809  "Function <vkCmdPushDescriptorSetWithTemplate2KHR> requires <VK_KHR_maintenance6>" );
22810 
22811  getDispatcher()->vkCmdPushDescriptorSetWithTemplate2KHR(
22812  static_cast<VkCommandBuffer>( m_commandBuffer ),
22813  reinterpret_cast<const VkPushDescriptorSetWithTemplateInfoKHR *>( &pushDescriptorSetWithTemplateInfo ) );
22814  }
22815 
22816  VULKAN_HPP_INLINE void CommandBuffer::setDescriptorBufferOffsets2EXT(
22817  const VULKAN_HPP_NAMESPACE::SetDescriptorBufferOffsetsInfoEXT & setDescriptorBufferOffsetsInfo ) const VULKAN_HPP_NOEXCEPT
22818  {
22820  "Function <vkCmdSetDescriptorBufferOffsets2EXT> requires <VK_KHR_maintenance6>" );
22821 
22822  getDispatcher()->vkCmdSetDescriptorBufferOffsets2EXT( static_cast<VkCommandBuffer>( m_commandBuffer ),
22823  reinterpret_cast<const VkSetDescriptorBufferOffsetsInfoEXT *>( &setDescriptorBufferOffsetsInfo ) );
22824  }
22825 
22826  VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorBufferEmbeddedSamplers2EXT(
22827  const VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT & bindDescriptorBufferEmbeddedSamplersInfo ) const VULKAN_HPP_NOEXCEPT
22828  {
22830  "Function <vkCmdBindDescriptorBufferEmbeddedSamplers2EXT> requires <VK_KHR_maintenance6>" );
22831 
22832  getDispatcher()->vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(
22833  static_cast<VkCommandBuffer>( m_commandBuffer ),
22834  reinterpret_cast<const VkBindDescriptorBufferEmbeddedSamplersInfoEXT *>( &bindDescriptorBufferEmbeddedSamplersInfo ) );
22835  }
22836 
22837  //====================
22838  //=== RAII Helpers ===
22839  //====================
22840 
22841  template <typename RAIIType>
22842  std::vector<typename RAIIType::CppType> filterCppTypes( std::vector<RAIIType> const & raiiTypes )
22843  {
22844  std::vector<typename RAIIType::CppType> cppTypes( raiiTypes.size() );
22845  std::transform( raiiTypes.begin(), raiiTypes.end(), cppTypes.begin(), []( RAIIType const & d ) { return *d; } );
22846  return cppTypes;
22847  }
22848 
22849  template <typename RAIIType, class UnaryPredicate>
22850  std::vector<typename RAIIType::CppType> filterCppTypes( std::vector<RAIIType> const & raiiTypes, UnaryPredicate p )
22851  {
22852  std::vector<typename RAIIType::CppType> cppTypes;
22853  for ( auto const & t : raiiTypes )
22854  {
22855  if ( p( t ) )
22856  {
22857  cppTypes.push_back( *t );
22858  }
22859  }
22860  return cppTypes;
22861  }
22862 
22863  } // namespace VULKAN_HPP_RAII_NAMESPACE
22864 } // namespace VULKAN_HPP_NAMESPACE
22865 #endif
22866 #endif
Definition: vulkan_handles.hpp:4091
Definition: vulkan_handles.hpp:3738
Definition: vulkan.hpp:260
Definition: vulkan_handles.hpp:6967
Definition: vulkan_handles.hpp:3135
Definition: vulkan_handles.hpp:4262
Definition: vulkan_handles.hpp:7054
Definition: vulkan_handles.hpp:7228
Definition: vulkan_handles.hpp:7315
Definition: vulkan_handles.hpp:7403
Definition: vulkan_handles.hpp:7492
Definition: vulkan_handles.hpp:2442
Definition: vulkan_handles.hpp:2532
Definition: vulkan_handles.hpp:6791
Definition: vulkan_handles.hpp:7580
Definition: vulkan_handles.hpp:7667
Definition: vulkan_handles.hpp:3309
Definition: vulkan_handles.hpp:3912
Definition: vulkan_handles.hpp:6623
Definition: vulkan_handles.hpp:8782
Definition: vulkan.hpp:1005
Definition: vulkan_handles.hpp:2616
Definition: vulkan_handles.hpp:13920
Definition: vulkan_handles.hpp:4004
Definition: vulkan_handles.hpp:2877
Definition: vulkan_handles.hpp:7757
Definition: vulkan_handles.hpp:3396
Definition: vulkan_handles.hpp:3651
Definition: vulkan_handles.hpp:7844
Definition: vulkan_handles.hpp:15429
Definition: vulkan.hpp:6177
Definition: vulkan_handles.hpp:4181
Definition: vulkan_handles.hpp:3828
Definition: vulkan.hpp:567
Definition: vulkan_handles.hpp:2964
Definition: vulkan_handles.hpp:14007
Definition: vulkan_handles.hpp:7141
Definition: vulkan_handles.hpp:3222
Definition: vulkan_handles.hpp:3483
Definition: vulkan_handles.hpp:7928
Definition: vulkan_handles.hpp:3048
Definition: vulkan_handles.hpp:8537
Definition: vulkan_handles.hpp:8011
Definition: vulkan_handles.hpp:8185
Definition: vulkan_handles.hpp:8098
Definition: vulkan_handles.hpp:2790
Definition: vulkan_handles.hpp:3570
Definition: vulkan_handles.hpp:8277
Definition: vulkan.hpp:526
Definition: vulkan.hpp:654
Definition: vulkan_handles.hpp:2355
Definition: vulkan_handles.hpp:2703
Definition: vulkan_handles.hpp:8364
Definition: vulkan_handles.hpp:6710
Definition: vulkan_handles.hpp:8453
Definition: vulkan_raii.hpp:4580
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:4651
vk::Device getDevice() const
Definition: vulkan_raii.hpp:4673
AccelerationStructureKHR(vk::raii::Device const &device, VkAccelerationStructureKHR accelerationStructure, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:4599
void swap(vk::raii::AccelerationStructureKHR &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:4684
AccelerationStructureKHR(std::nullptr_t)
Definition: vulkan_raii.hpp:4609
VkAccelerationStructureKHR CType
Definition: vulkan_raii.hpp:4582
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:4678
vk::AccelerationStructureKHR const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:4641
vk::AccelerationStructureKHR release()
Definition: vulkan_raii.hpp:4665
~AccelerationStructureKHR()
Definition: vulkan_raii.hpp:4611
AccelerationStructureKHR(vk::raii::Device const &device, vk::AccelerationStructureCreateInfoKHR const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:4591
AccelerationStructureKHR(AccelerationStructureKHR const &)=delete
AccelerationStructureKHR & operator=(AccelerationStructureKHR &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:4629
AccelerationStructureKHR(AccelerationStructureKHR &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:4619
AccelerationStructureKHR & operator=(AccelerationStructureKHR const &)=delete
Definition: vulkan_raii.hpp:4700
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:4771
AccelerationStructureNV(AccelerationStructureNV const &)=delete
vk::AccelerationStructureNV const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:4761
void swap(vk::raii::AccelerationStructureNV &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:4804
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:4798
vk::AccelerationStructureNV release()
Definition: vulkan_raii.hpp:4785
AccelerationStructureNV(vk::raii::Device const &device, VkAccelerationStructureNV accelerationStructure, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:4719
VULKAN_HPP_NODISCARD std::vector< DataType > getHandle(size_t dataSize) const
AccelerationStructureNV & operator=(AccelerationStructureNV const &)=delete
AccelerationStructureNV(AccelerationStructureNV &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:4739
vk::Device getDevice() const
Definition: vulkan_raii.hpp:4793
~AccelerationStructureNV()
Definition: vulkan_raii.hpp:4731
VkAccelerationStructureNV CType
Definition: vulkan_raii.hpp:4702
AccelerationStructureNV & operator=(AccelerationStructureNV &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:4749
AccelerationStructureNV(std::nullptr_t)
Definition: vulkan_raii.hpp:4729
AccelerationStructureNV(vk::raii::Device const &device, vk::AccelerationStructureCreateInfoNV const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:4711
VULKAN_HPP_NODISCARD DataType getHandle() const
Definition: vulkan_raii.hpp:5083
vk::BufferView release()
Definition: vulkan_raii.hpp:5167
void swap(vk::raii::BufferView &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:5186
vk::BufferView const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:5144
~BufferView()
Definition: vulkan_raii.hpp:5114
VkBufferView CType
Definition: vulkan_raii.hpp:5085
BufferView(vk::raii::Device const &device, vk::BufferViewCreateInfo const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:5094
vk::Device getDevice() const
Definition: vulkan_raii.hpp:5175
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:5154
BufferView & operator=(BufferView &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:5132
BufferView(vk::raii::Device const &device, VkBufferView bufferView, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:5102
BufferView(BufferView const &)=delete
BufferView(BufferView &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:5122
BufferView & operator=(BufferView const &)=delete
BufferView(std::nullptr_t)
Definition: vulkan_raii.hpp:5112
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:5180
Definition: vulkan_raii.hpp:4828
Buffer(Buffer &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:4867
Buffer & operator=(Buffer &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:4877
VkBuffer CType
Definition: vulkan_raii.hpp:4830
Buffer(vk::raii::Device const &device, vk::BufferCreateInfo const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:4839
vk::Device getDevice() const
Definition: vulkan_raii.hpp:4920
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:4899
Buffer & operator=(Buffer const &)=delete
Buffer(std::nullptr_t)
Definition: vulkan_raii.hpp:4857
vk::Buffer const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:4889
Buffer(vk::raii::Device const &device, VkBuffer buffer, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:4847
~Buffer()
Definition: vulkan_raii.hpp:4859
void swap(vk::raii::Buffer &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:4931
Buffer(Buffer const &)=delete
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:4925
vk::Buffer release()
Definition: vulkan_raii.hpp:4912
Definition: vulkan_raii.hpp:5333
vk::CommandBuffer release()
Definition: vulkan_raii.hpp:5403
void swap(vk::raii::CommandBuffer &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:5422
vk::CommandBuffer const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:5380
void setCheckpointNV(CheckpointMarkerType const &checkpointMarker) const VULKAN_HPP_NOEXCEPT
void updateBuffer(vk::Buffer dstBuffer, vk::DeviceSize dstOffset, vk::ArrayProxy< const DataType > const &data) const VULKAN_HPP_NOEXCEPT
CommandBuffer(vk::raii::Device const &device, VkCommandBuffer commandBuffer, VkCommandPool commandPool)
Definition: vulkan_raii.hpp:5343
CommandBuffer(CommandBuffer const &)=delete
CommandBuffer & operator=(CommandBuffer const &)=delete
void bindVertexBuffers2EXT(uint32_t firstBinding, vk::ArrayProxy< const vk::Buffer > const &buffers, vk::ArrayProxy< const vk::DeviceSize > const &offsets, vk::ArrayProxy< const vk::DeviceSize > const &sizes VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, vk::ArrayProxy< const vk::DeviceSize > const &strides VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT) const
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:5416
CommandBuffer(std::nullptr_t)
Definition: vulkan_raii.hpp:5348
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:5390
CommandBuffer & operator=(CommandBuffer &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:5368
VkCommandBuffer CType
Definition: vulkan_raii.hpp:5335
~CommandBuffer()
Definition: vulkan_raii.hpp:5350
void pushConstants(vk::PipelineLayout layout, vk::ShaderStageFlags stageFlags, uint32_t offset, vk::ArrayProxy< const ValuesType > const &values) const VULKAN_HPP_NOEXCEPT
CommandBuffer(CommandBuffer &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:5358
vk::Device getDevice() const
Definition: vulkan_raii.hpp:5411
Definition: vulkan_raii.hpp:6367
CommandBuffers(std::nullptr_t)
Definition: vulkan_raii.hpp:6377
CommandBuffers & operator=(CommandBuffers &&rhs)=default
CommandBuffers(vk::raii::Device const &device, vk::CommandBufferAllocateInfo const &allocateInfo)
Definition: vulkan_raii.hpp:6370
CommandBuffers(CommandBuffers const &)=delete
CommandBuffers & operator=(CommandBuffers const &)=delete
CommandBuffers(CommandBuffers &&rhs)=default
Definition: vulkan_raii.hpp:5202
vk::CommandPool const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:5263
vk::Device getDevice() const
Definition: vulkan_raii.hpp:5294
CommandPool(CommandPool const &)=delete
CommandPool & operator=(CommandPool &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:5251
CommandPool(vk::raii::Device const &device, VkCommandPool commandPool, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:5221
CommandPool(vk::raii::Device const &device, vk::CommandPoolCreateInfo const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:5213
VkCommandPool CType
Definition: vulkan_raii.hpp:5204
CommandPool(std::nullptr_t)
Definition: vulkan_raii.hpp:5231
~CommandPool()
Definition: vulkan_raii.hpp:5233
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:5273
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:5299
CommandPool(CommandPool &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:5241
CommandPool & operator=(CommandPool const &)=delete
void swap(vk::raii::CommandPool &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:5305
vk::CommandPool release()
Definition: vulkan_raii.hpp:5286
Definition: vulkan_raii.hpp:44
ContextDispatcher(PFN_vkGetInstanceProcAddr getProcAddr)
Definition: vulkan_raii.hpp:46
Definition: vulkan_raii.hpp:2696
Context(Context const &)=delete
Context & operator=(Context const &)=delete
void swap(vk::raii::Context &rhs)
Definition: vulkan_raii.hpp:2741
Context(PFN_vkGetInstanceProcAddr getInstanceProcAddr)
Definition: vulkan_raii.hpp:2703
vk::raii::ContextDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:2735
~Context()=default
Context & operator=(Context &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:2723
Context(Context &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:2712
Definition: vulkan_raii.hpp:34
T Type
Definition: vulkan_raii.hpp:39
Definition: vulkan_raii.hpp:6393
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:6464
vk::CuFunctionNVX const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:6454
CuFunctionNVX & operator=(CuFunctionNVX const &)=delete
CuFunctionNVX(vk::raii::Device const &device, VkCuFunctionNVX function, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:6412
CuFunctionNVX & operator=(CuFunctionNVX &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:6442
vk::Device getDevice() const
Definition: vulkan_raii.hpp:6485
void swap(vk::raii::CuFunctionNVX &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:6496
~CuFunctionNVX()
Definition: vulkan_raii.hpp:6424
CuFunctionNVX(CuFunctionNVX &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:6432
CuFunctionNVX(CuFunctionNVX const &)=delete
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:6490
CuFunctionNVX(vk::raii::Device const &device, vk::CuFunctionCreateInfoNVX const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:6404
VkCuFunctionNVX CType
Definition: vulkan_raii.hpp:6395
vk::CuFunctionNVX release()
Definition: vulkan_raii.hpp:6477
CuFunctionNVX(std::nullptr_t)
Definition: vulkan_raii.hpp:6422
Definition: vulkan_raii.hpp:6512
CuModuleNVX(std::nullptr_t)
Definition: vulkan_raii.hpp:6541
CuModuleNVX & operator=(CuModuleNVX const &)=delete
vk::CuModuleNVX release()
Definition: vulkan_raii.hpp:6596
CuModuleNVX(vk::raii::Device const &device, vk::CuModuleCreateInfoNVX const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:6523
vk::CuModuleNVX const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:6573
CuModuleNVX(CuModuleNVX &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:6551
vk::Device getDevice() const
Definition: vulkan_raii.hpp:6604
CuModuleNVX & operator=(CuModuleNVX &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:6561
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:6609
CuModuleNVX(CuModuleNVX const &)=delete
void swap(vk::raii::CuModuleNVX &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:6615
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:6583
VkCuModuleNVX CType
Definition: vulkan_raii.hpp:6514
CuModuleNVX(vk::raii::Device const &device, VkCuModuleNVX module, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:6531
~CuModuleNVX()
Definition: vulkan_raii.hpp:6543
Definition: vulkan_raii.hpp:6632
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:6703
void swap(vk::raii::CudaFunctionNV &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:6735
CudaFunctionNV(CudaFunctionNV const &)=delete
CudaFunctionNV(vk::raii::Device const &device, vk::CudaFunctionCreateInfoNV const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:6643
vk::CudaFunctionNV const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:6693
~CudaFunctionNV()
Definition: vulkan_raii.hpp:6663
vk::CudaFunctionNV release()
Definition: vulkan_raii.hpp:6716
CudaFunctionNV(vk::raii::Device const &device, VkCudaFunctionNV function, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:6651
CudaFunctionNV(std::nullptr_t)
Definition: vulkan_raii.hpp:6661
vk::Device getDevice() const
Definition: vulkan_raii.hpp:6724
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:6729
CudaFunctionNV(CudaFunctionNV &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:6671
CudaFunctionNV & operator=(CudaFunctionNV &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:6681
CudaFunctionNV & operator=(CudaFunctionNV const &)=delete
VkCudaFunctionNV CType
Definition: vulkan_raii.hpp:6634
Definition: vulkan_raii.hpp:6753
VkCudaModuleNV CType
Definition: vulkan_raii.hpp:6755
vk::CudaModuleNV release()
Definition: vulkan_raii.hpp:6837
CudaModuleNV(vk::raii::Device const &device, VkCudaModuleNV module, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:6772
void swap(vk::raii::CudaModuleNV &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:6856
CudaModuleNV & operator=(CudaModuleNV &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:6802
CudaModuleNV(vk::raii::Device const &device, vk::CudaModuleCreateInfoNV const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:6764
CudaModuleNV(std::nullptr_t)
Definition: vulkan_raii.hpp:6782
vk::CudaModuleNV const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:6814
vk::Device getDevice() const
Definition: vulkan_raii.hpp:6845
CudaModuleNV & operator=(CudaModuleNV const &)=delete
CudaModuleNV(CudaModuleNV &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:6792
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:6850
CudaModuleNV(CudaModuleNV const &)=delete
~CudaModuleNV()
Definition: vulkan_raii.hpp:6784
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:6824
Definition: vulkan_raii.hpp:6877
DebugReportCallbackEXT & operator=(DebugReportCallbackEXT const &)=delete
~DebugReportCallbackEXT()
Definition: vulkan_raii.hpp:6908
DebugReportCallbackEXT(DebugReportCallbackEXT &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:6916
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:6948
vk::Instance getInstance() const
Definition: vulkan_raii.hpp:6970
vk::DebugReportCallbackEXT release()
Definition: vulkan_raii.hpp:6962
DebugReportCallbackEXT(vk::raii::Instance const &instance, vk::DebugReportCallbackCreateInfoEXT const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:6888
vk::DebugReportCallbackEXT const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:6938
void swap(vk::raii::DebugReportCallbackEXT &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:6981
DebugReportCallbackEXT & operator=(DebugReportCallbackEXT &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:6926
DebugReportCallbackEXT(DebugReportCallbackEXT const &)=delete
vk::raii::InstanceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:6975
VkDebugReportCallbackEXT CType
Definition: vulkan_raii.hpp:6879
DebugReportCallbackEXT(std::nullptr_t)
Definition: vulkan_raii.hpp:6906
DebugReportCallbackEXT(vk::raii::Instance const &instance, VkDebugReportCallbackEXT callback, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:6896
Definition: vulkan_raii.hpp:6997
DebugUtilsMessengerEXT(vk::raii::Instance const &instance, vk::DebugUtilsMessengerCreateInfoEXT const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:7008
VkDebugUtilsMessengerEXT CType
Definition: vulkan_raii.hpp:6999
DebugUtilsMessengerEXT & operator=(DebugUtilsMessengerEXT const &)=delete
DebugUtilsMessengerEXT(vk::raii::Instance const &instance, VkDebugUtilsMessengerEXT messenger, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:7016
DebugUtilsMessengerEXT(DebugUtilsMessengerEXT &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7036
vk::raii::InstanceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:7095
DebugUtilsMessengerEXT(std::nullptr_t)
Definition: vulkan_raii.hpp:7026
~DebugUtilsMessengerEXT()
Definition: vulkan_raii.hpp:7028
vk::DebugUtilsMessengerEXT const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7058
void swap(vk::raii::DebugUtilsMessengerEXT &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7101
DebugUtilsMessengerEXT & operator=(DebugUtilsMessengerEXT &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7046
vk::DebugUtilsMessengerEXT release()
Definition: vulkan_raii.hpp:7082
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7068
DebugUtilsMessengerEXT(DebugUtilsMessengerEXT const &)=delete
vk::Instance getInstance() const
Definition: vulkan_raii.hpp:7090
Definition: vulkan_raii.hpp:7117
VkDeferredOperationKHR CType
Definition: vulkan_raii.hpp:7119
DeferredOperationKHR(DeferredOperationKHR const &)=delete
~DeferredOperationKHR()
Definition: vulkan_raii.hpp:7147
DeferredOperationKHR(vk::raii::Device const &device, VkDeferredOperationKHR operation, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:7135
DeferredOperationKHR & operator=(DeferredOperationKHR const &)=delete
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:7214
DeferredOperationKHR(DeferredOperationKHR &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7155
vk::DeferredOperationKHR const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7177
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7187
DeferredOperationKHR & operator=(DeferredOperationKHR &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7165
DeferredOperationKHR(std::nullptr_t)
Definition: vulkan_raii.hpp:7145
vk::Device getDevice() const
Definition: vulkan_raii.hpp:7209
void swap(vk::raii::DeferredOperationKHR &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7220
vk::DeferredOperationKHR release()
Definition: vulkan_raii.hpp:7201
DeferredOperationKHR(vk::raii::Device const &device, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:7128
Definition: vulkan_raii.hpp:7244
DescriptorPool(DescriptorPool const &)=delete
DescriptorPool(std::nullptr_t)
Definition: vulkan_raii.hpp:7273
DescriptorPool & operator=(DescriptorPool &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7293
vk::Device getDevice() const
Definition: vulkan_raii.hpp:7337
DescriptorPool(DescriptorPool &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7283
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:7342
~DescriptorPool()
Definition: vulkan_raii.hpp:7275
VkDescriptorPool CType
Definition: vulkan_raii.hpp:7246
DescriptorPool(vk::raii::Device const &device, vk::DescriptorPoolCreateInfo const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:7255
DescriptorPool(vk::raii::Device const &device, VkDescriptorPool descriptorPool, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:7263
vk::DescriptorPool release()
Definition: vulkan_raii.hpp:7329
void swap(vk::raii::DescriptorPool &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7348
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7315
DescriptorPool & operator=(DescriptorPool const &)=delete
vk::DescriptorPool const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7305
Definition: vulkan_raii.hpp:7515
DescriptorSetLayout(vk::raii::Device const &device, VkDescriptorSetLayout descriptorSetLayout, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:7534
~DescriptorSetLayout()
Definition: vulkan_raii.hpp:7546
vk::Device getDevice() const
Definition: vulkan_raii.hpp:7608
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:7613
DescriptorSetLayout(std::nullptr_t)
Definition: vulkan_raii.hpp:7544
DescriptorSetLayout & operator=(DescriptorSetLayout &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7564
vk::DescriptorSetLayout release()
Definition: vulkan_raii.hpp:7600
DescriptorSetLayout(DescriptorSetLayout const &)=delete
VkDescriptorSetLayout CType
Definition: vulkan_raii.hpp:7517
vk::DescriptorSetLayout const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7576
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7586
void swap(vk::raii::DescriptorSetLayout &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7619
DescriptorSetLayout(vk::raii::Device const &device, vk::DescriptorSetLayoutCreateInfo const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:7526
DescriptorSetLayout & operator=(DescriptorSetLayout const &)=delete
DescriptorSetLayout(DescriptorSetLayout &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7554
Definition: vulkan_raii.hpp:7368
vk::Device getDevice() const
Definition: vulkan_raii.hpp:7448
vk::DescriptorSet release()
Definition: vulkan_raii.hpp:7440
DescriptorSet(vk::raii::Device const &device, VkDescriptorSet descriptorSet, VkDescriptorPool descriptorPool)
Definition: vulkan_raii.hpp:7378
void updateWithTemplate(vk::DescriptorUpdateTemplate descriptorUpdateTemplate, DataType const &data) const VULKAN_HPP_NOEXCEPT
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:7453
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7425
DescriptorSet(DescriptorSet const &)=delete
DescriptorSet & operator=(DescriptorSet const &)=delete
DescriptorSet(std::nullptr_t)
Definition: vulkan_raii.hpp:7383
~DescriptorSet()
Definition: vulkan_raii.hpp:7385
DescriptorSet(DescriptorSet &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7393
VkDescriptorSet CType
Definition: vulkan_raii.hpp:7370
void swap(vk::raii::DescriptorSet &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7459
vk::DescriptorSet const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7415
DescriptorSet & operator=(DescriptorSet &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7403
void updateWithTemplateKHR(vk::DescriptorUpdateTemplate descriptorUpdateTemplate, DataType const &data) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7489
DescriptorSets & operator=(DescriptorSets &&rhs)=default
DescriptorSets(std::nullptr_t)
Definition: vulkan_raii.hpp:7499
DescriptorSets & operator=(DescriptorSets const &)=delete
DescriptorSets(vk::raii::Device const &device, vk::DescriptorSetAllocateInfo const &allocateInfo)
Definition: vulkan_raii.hpp:7492
DescriptorSets(DescriptorSets &&rhs)=default
DescriptorSets(DescriptorSets const &)=delete
Definition: vulkan_raii.hpp:7641
vk::Device getDevice() const
Definition: vulkan_raii.hpp:7734
void swap(vk::raii::DescriptorUpdateTemplate &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7745
VkDescriptorUpdateTemplate CType
Definition: vulkan_raii.hpp:7643
vk::DescriptorUpdateTemplate release()
Definition: vulkan_raii.hpp:7726
DescriptorUpdateTemplate & operator=(DescriptorUpdateTemplate &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7690
DescriptorUpdateTemplate(vk::raii::Device const &device, vk::DescriptorUpdateTemplateCreateInfo const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:7652
~DescriptorUpdateTemplate()
Definition: vulkan_raii.hpp:7672
DescriptorUpdateTemplate(std::nullptr_t)
Definition: vulkan_raii.hpp:7670
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7712
DescriptorUpdateTemplate(DescriptorUpdateTemplate const &)=delete
DescriptorUpdateTemplate & operator=(DescriptorUpdateTemplate const &)=delete
DescriptorUpdateTemplate(vk::raii::Device const &device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:7660
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:7739
vk::DescriptorUpdateTemplate const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7702
DescriptorUpdateTemplate(DescriptorUpdateTemplate &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7680
Definition: vulkan_raii.hpp:670
DeviceDispatcher(PFN_vkGetDeviceProcAddr getProcAddr, VkDevice device)
Definition: vulkan_raii.hpp:672
Definition: vulkan_raii.hpp:7761
DeviceMemory(vk::raii::Device const &device, vk::MemoryAllocateInfo const &allocateInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:7772
vk::DeviceMemory release()
Definition: vulkan_raii.hpp:7845
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7832
~DeviceMemory()
Definition: vulkan_raii.hpp:7792
DeviceMemory(DeviceMemory &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7800
DeviceMemory & operator=(DeviceMemory &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7810
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:7858
DeviceMemory(std::nullptr_t)
Definition: vulkan_raii.hpp:7790
void swap(vk::raii::DeviceMemory &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7864
DeviceMemory(DeviceMemory const &)=delete
vk::Device getDevice() const
Definition: vulkan_raii.hpp:7853
DeviceMemory(vk::raii::Device const &device, VkDeviceMemory memory, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:7780
DeviceMemory & operator=(DeviceMemory const &)=delete
VkDeviceMemory CType
Definition: vulkan_raii.hpp:7763
vk::DeviceMemory const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7822
Definition: vulkan_raii.hpp:3511
void swap(vk::raii::Device &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:3603
VULKAN_HPP_NODISCARD DataType getSamplerOpaqueCaptureDescriptorDataEXT(const vk::SamplerCaptureDescriptorDataInfoEXT &info) const
Device(vk::raii::PhysicalDevice const &physicalDevice, VkDevice device, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:3530
VULKAN_HPP_NODISCARD DataType getImageOpaqueCaptureDescriptorDataEXT(const vk::ImageCaptureDescriptorDataInfoEXT &info) const
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:3579
VkDevice CType
Definition: vulkan_raii.hpp:3513
Device(std::nullptr_t)
Definition: vulkan_raii.hpp:3539
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getBufferMemoryRequirements2KHR(const vk::BufferMemoryRequirementsInfo2 &info) const VULKAN_HPP_NOEXCEPT
Device(vk::raii::PhysicalDevice const &physicalDevice, vk::DeviceCreateInfo const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:3522
Device(Device const &)=delete
VULKAN_HPP_NODISCARD DataType getAccelerationStructureOpaqueCaptureDescriptorDataEXT(const vk::AccelerationStructureCaptureDescriptorDataInfoEXT &info) const
vk::Device const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:3569
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getImageMemoryRequirements2KHR(const vk::ImageMemoryRequirementsInfo2 &info) const VULKAN_HPP_NOEXCEPT
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:3597
VULKAN_HPP_NODISCARD DescriptorType getDescriptorEXT(const vk::DescriptorGetInfoEXT &descriptorInfo) const VULKAN_HPP_NOEXCEPT
Device & operator=(Device &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:3558
VULKAN_HPP_NODISCARD DataType getBufferOpaqueCaptureDescriptorDataEXT(const vk::BufferCaptureDescriptorDataInfoEXT &info) const
Device & operator=(Device const &)=delete
~Device()
Definition: vulkan_raii.hpp:3541
vk::Device release()
Definition: vulkan_raii.hpp:3590
VULKAN_HPP_NODISCARD DataType getImageViewOpaqueCaptureDescriptorDataEXT(const vk::ImageViewCaptureDescriptorDataInfoEXT &info) const
Device(Device &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:3549
Definition: vulkan_raii.hpp:7900
vk::DisplayKHR const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7970
vk::raii::InstanceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:8003
DisplayKHR & operator=(DisplayKHR &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7959
DisplayKHR(std::nullptr_t)
Definition: vulkan_raii.hpp:7940
~DisplayKHR()
Definition: vulkan_raii.hpp:7942
VkDisplayKHR CType
Definition: vulkan_raii.hpp:7902
DisplayKHR(vk::raii::PhysicalDevice const &physicalDevice, int32_t drmFd, uint32_t connectorId)
Definition: vulkan_raii.hpp:7911
DisplayKHR(DisplayKHR const &)=delete
DisplayKHR(vk::raii::PhysicalDevice const &physicalDevice, VkDisplayKHR display)
Definition: vulkan_raii.hpp:7935
vk::PhysicalDevice getPhysicalDevice() const
Definition: vulkan_raii.hpp:7998
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7980
DisplayKHR & operator=(DisplayKHR const &)=delete
DisplayKHR(DisplayKHR &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:7950
vk::DisplayKHR release()
Definition: vulkan_raii.hpp:7991
void swap(vk::raii::DisplayKHR &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:8009
Definition: vulkan_raii.hpp:8042
DisplayKHRs(std::nullptr_t)
Definition: vulkan_raii.hpp:8051
DisplayKHRs(vk::raii::PhysicalDevice const &physicalDevice, uint32_t planeIndex)
Definition: vulkan_raii.hpp:8045
DisplayKHRs(DisplayKHRs const &)=delete
DisplayKHRs & operator=(DisplayKHRs &&rhs)=default
DisplayKHRs(DisplayKHRs &&rhs)=default
DisplayKHRs & operator=(DisplayKHRs const &)=delete
Definition: vulkan_raii.hpp:8067
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:8137
vk::raii::InstanceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:8151
DisplayModeKHR(DisplayModeKHR const &rhs)
Definition: vulkan_raii.hpp:8100
void swap(vk::raii::DisplayModeKHR &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:8157
vk::DisplayModeKHR const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:8127
DisplayModeKHR(vk::raii::DisplayKHR const &display, vk::DisplayModeCreateInfoKHR const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:8078
DisplayModeKHR(vk::raii::DisplayKHR const &display, VkDisplayModeKHR displayModeKHR)
Definition: vulkan_raii.hpp:8086
DisplayModeKHR & operator=(DisplayModeKHR &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:8116
~DisplayModeKHR()
Definition: vulkan_raii.hpp:8093
DisplayModeKHR(DisplayModeKHR &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:8102
VkDisplayModeKHR CType
Definition: vulkan_raii.hpp:8069
DisplayModeKHR(std::nullptr_t)
Definition: vulkan_raii.hpp:8091
vk::DisplayModeKHR release()
Definition: vulkan_raii.hpp:8144
DisplayModeKHR & operator=(DisplayModeKHR const &rhs)
Definition: vulkan_raii.hpp:8109
Definition: vulkan_raii.hpp:8175
Event(vk::raii::Device const &device, VkEvent event, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:8194
vk::Event const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:8236
void swap(vk::raii::Event &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:8278
Event(vk::raii::Device const &device, vk::EventCreateInfo const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:8186
Event(Event &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:8214
VkEvent CType
Definition: vulkan_raii.hpp:8177
Event & operator=(Event &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:8224
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:8272
Event(Event const &)=delete
vk::Event release()
Definition: vulkan_raii.hpp:8259
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:8246
vk::Device getDevice() const
Definition: vulkan_raii.hpp:8267
Event & operator=(Event const &)=delete
~Event()
Definition: vulkan_raii.hpp:8206
Event(std::nullptr_t)
Definition: vulkan_raii.hpp:8204
Definition: vulkan_raii.hpp:8302
Fence(Fence &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:8360
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:8392
VkFence CType
Definition: vulkan_raii.hpp:8304
Fence & operator=(Fence &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:8370
vk::Fence const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:8382
~Fence()
Definition: vulkan_raii.hpp:8352
void swap(vk::raii::Fence &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:8424
Fence(vk::raii::Device const &device, vk::raii::DisplayKHR const &display, vk::DisplayEventInfoEXT const &displayEventInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:8331
Fence(vk::raii::Device const &device, vk::FenceCreateInfo const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:8313
Fence(Fence const &)=delete
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:8418
vk::Device getDevice() const
Definition: vulkan_raii.hpp:8413
Fence(vk::raii::Device const &device, vk::DeviceEventInfoEXT const &deviceEventInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:8322
vk::Fence release()
Definition: vulkan_raii.hpp:8405
Fence & operator=(Fence const &)=delete
Fence(vk::raii::Device const &device, VkFence fence, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:8340
Fence(std::nullptr_t)
Definition: vulkan_raii.hpp:8350
Definition: vulkan_raii.hpp:8444
Framebuffer(vk::raii::Device const &device, vk::FramebufferCreateInfo const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:8455
void swap(vk::raii::Framebuffer &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:8547
Framebuffer(std::nullptr_t)
Definition: vulkan_raii.hpp:8473
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:8515
Framebuffer & operator=(Framebuffer const &)=delete
Framebuffer & operator=(Framebuffer &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:8493
vk::Framebuffer release()
Definition: vulkan_raii.hpp:8528
Framebuffer(Framebuffer &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:8483
vk::Device getDevice() const
Definition: vulkan_raii.hpp:8536
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:8541
VkFramebuffer CType
Definition: vulkan_raii.hpp:8446
vk::Framebuffer const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:8505
~Framebuffer()
Definition: vulkan_raii.hpp:8475
Framebuffer(Framebuffer const &)=delete
Framebuffer(vk::raii::Device const &device, VkFramebuffer framebuffer, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:8463
Definition: vulkan_raii.hpp:8719
vk::ImageView const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:8780
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:8816
ImageView & operator=(ImageView &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:8768
vk::ImageView release()
Definition: vulkan_raii.hpp:8803
void swap(vk::raii::ImageView &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:8822
~ImageView()
Definition: vulkan_raii.hpp:8750
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:8790
ImageView(vk::raii::Device const &device, VkImageView imageView, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:8738
ImageView(vk::raii::Device const &device, vk::ImageViewCreateInfo const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:8730
ImageView(ImageView &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:8758
vk::Device getDevice() const
Definition: vulkan_raii.hpp:8811
ImageView(ImageView const &)=delete
ImageView & operator=(ImageView const &)=delete
VkImageView CType
Definition: vulkan_raii.hpp:8721
ImageView(std::nullptr_t)
Definition: vulkan_raii.hpp:8748
Definition: vulkan_raii.hpp:8567
void swap(vk::raii::Image &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:8670
Image(Image &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:8606
vk::Image const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:8628
vk::Image release()
Definition: vulkan_raii.hpp:8651
Image(Image const &)=delete
Image(vk::raii::Device const &device, vk::ImageCreateInfo const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:8578
vk::Device getDevice() const
Definition: vulkan_raii.hpp:8659
Image & operator=(Image &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:8616
Image(vk::raii::Device const &device, VkImage image, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:8586
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:8638
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:8664
VkImage CType
Definition: vulkan_raii.hpp:8569
~Image()
Definition: vulkan_raii.hpp:8598
Image(std::nullptr_t)
Definition: vulkan_raii.hpp:8596
Image & operator=(Image const &)=delete
Definition: vulkan_raii.hpp:8842
vk::Device getDevice() const
Definition: vulkan_raii.hpp:8935
void swap(vk::raii::IndirectCommandsLayoutNV &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:8946
VkIndirectCommandsLayoutNV CType
Definition: vulkan_raii.hpp:8844
IndirectCommandsLayoutNV(IndirectCommandsLayoutNV const &)=delete
IndirectCommandsLayoutNV & operator=(IndirectCommandsLayoutNV &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:8891
vk::IndirectCommandsLayoutNV const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:8903
IndirectCommandsLayoutNV(vk::raii::Device const &device, VkIndirectCommandsLayoutNV indirectCommandsLayout, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:8861
IndirectCommandsLayoutNV(std::nullptr_t)
Definition: vulkan_raii.hpp:8871
IndirectCommandsLayoutNV(vk::raii::Device const &device, vk::IndirectCommandsLayoutCreateInfoNV const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:8853
IndirectCommandsLayoutNV(IndirectCommandsLayoutNV &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:8881
IndirectCommandsLayoutNV & operator=(IndirectCommandsLayoutNV const &)=delete
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:8940
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:8913
~IndirectCommandsLayoutNV()
Definition: vulkan_raii.hpp:8873
vk::IndirectCommandsLayoutNV release()
Definition: vulkan_raii.hpp:8927
Definition: vulkan_raii.hpp:70
InstanceDispatcher(PFN_vkGetInstanceProcAddr getProcAddr, VkInstance instance)
Definition: vulkan_raii.hpp:72
Definition: vulkan_raii.hpp:2773
VkInstance CType
Definition: vulkan_raii.hpp:2775
vk::Instance release()
Definition: vulkan_raii.hpp:2852
~Instance()
Definition: vulkan_raii.hpp:2803
Instance & operator=(Instance const &)=delete
Instance(Instance &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:2811
Instance & operator=(Instance &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:2820
void swap(vk::raii::Instance &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:2865
Instance(std::nullptr_t)
Definition: vulkan_raii.hpp:2801
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:2841
vk::raii::InstanceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:2859
Instance(vk::raii::Context const &context, VkInstance instance, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:2792
Instance(vk::raii::Context const &context, vk::InstanceCreateInfo const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:2784
Instance(Instance const &)=delete
vk::Instance const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:2831
Definition: vulkan_raii.hpp:8962
VkMicromapEXT CType
Definition: vulkan_raii.hpp:8964
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:9059
MicromapEXT & operator=(MicromapEXT &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:9011
vk::MicromapEXT release()
Definition: vulkan_raii.hpp:9046
MicromapEXT(vk::raii::Device const &device, VkMicromapEXT micromap, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:8981
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:9033
MicromapEXT(vk::raii::Device const &device, vk::MicromapCreateInfoEXT const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:8973
void swap(vk::raii::MicromapEXT &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:9065
MicromapEXT(MicromapEXT &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:9001
~MicromapEXT()
Definition: vulkan_raii.hpp:8993
MicromapEXT & operator=(MicromapEXT const &)=delete
MicromapEXT(std::nullptr_t)
Definition: vulkan_raii.hpp:8991
vk::MicromapEXT const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:9023
vk::Device getDevice() const
Definition: vulkan_raii.hpp:9054
MicromapEXT(MicromapEXT const &)=delete
Definition: vulkan_raii.hpp:9081
vk::OpticalFlowSessionNV release()
Definition: vulkan_raii.hpp:9166
OpticalFlowSessionNV(std::nullptr_t)
Definition: vulkan_raii.hpp:9110
OpticalFlowSessionNV(vk::raii::Device const &device, VkOpticalFlowSessionNV session, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:9100
void swap(vk::raii::OpticalFlowSessionNV &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:9185
vk::OpticalFlowSessionNV const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:9142
OpticalFlowSessionNV(OpticalFlowSessionNV &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:9120
VkOpticalFlowSessionNV CType
Definition: vulkan_raii.hpp:9083
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:9179
OpticalFlowSessionNV & operator=(OpticalFlowSessionNV const &)=delete
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:9152
OpticalFlowSessionNV(vk::raii::Device const &device, vk::OpticalFlowSessionCreateInfoNV const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:9092
vk::Device getDevice() const
Definition: vulkan_raii.hpp:9174
~OpticalFlowSessionNV()
Definition: vulkan_raii.hpp:9112
OpticalFlowSessionNV(OpticalFlowSessionNV const &)=delete
OpticalFlowSessionNV & operator=(OpticalFlowSessionNV &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:9130
Definition: vulkan_raii.hpp:9207
PerformanceConfigurationINTEL(PerformanceConfigurationINTEL const &)=delete
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:9294
PerformanceConfigurationINTEL(vk::raii::Device const &device, VkPerformanceConfigurationINTEL configuration)
Definition: vulkan_raii.hpp:9225
vk::Device getDevice() const
Definition: vulkan_raii.hpp:9289
vk::PerformanceConfigurationINTEL const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:9260
VkPerformanceConfigurationINTEL CType
Definition: vulkan_raii.hpp:9209
vk::PerformanceConfigurationINTEL release()
Definition: vulkan_raii.hpp:9282
PerformanceConfigurationINTEL & operator=(PerformanceConfigurationINTEL const &)=delete
PerformanceConfigurationINTEL(std::nullptr_t)
Definition: vulkan_raii.hpp:9230
PerformanceConfigurationINTEL(vk::raii::Device const &device, vk::PerformanceConfigurationAcquireInfoINTEL const &acquireInfo)
Definition: vulkan_raii.hpp:9218
PerformanceConfigurationINTEL & operator=(PerformanceConfigurationINTEL &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:9249
~PerformanceConfigurationINTEL()
Definition: vulkan_raii.hpp:9232
PerformanceConfigurationINTEL(PerformanceConfigurationINTEL &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:9240
void swap(vk::raii::PerformanceConfigurationINTEL &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:9300
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:9270
Definition: vulkan_raii.hpp:3054
VkPhysicalDevice CType
Definition: vulkan_raii.hpp:3056
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getVideoEncodeQualityLevelPropertiesKHR(const vk::PhysicalDeviceVideoEncodeQualityLevelInfoKHR &qualityLevelInfo) const
PhysicalDevice(vk::raii::Instance const &instance, VkPhysicalDevice physicalDevice)
Definition: vulkan_raii.hpp:3064
vk::raii::InstanceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:3125
PhysicalDevice(PhysicalDevice const &rhs)
Definition: vulkan_raii.hpp:3078
PhysicalDevice(std::nullptr_t)
Definition: vulkan_raii.hpp:3069
PhysicalDevice(PhysicalDevice &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:3080
vk::PhysicalDevice release()
Definition: vulkan_raii.hpp:3119
VULKAN_HPP_NODISCARD std::vector< StructureChain > getSurfaceFormats2KHR(const vk::PhysicalDeviceSurfaceInfo2KHR &surfaceInfo) const
vk::PhysicalDevice const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:3103
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getSurfaceCapabilities2KHR(const vk::PhysicalDeviceSurfaceInfo2KHR &surfaceInfo) const
PhysicalDevice & operator=(PhysicalDevice const &rhs)
Definition: vulkan_raii.hpp:3086
void swap(vk::raii::PhysicalDevice &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:3131
PhysicalDevice & operator=(PhysicalDevice &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:3093
VULKAN_HPP_NODISCARD vk::StructureChain< X, Y, Z... > getVideoCapabilitiesKHR(const vk::VideoProfileInfoKHR &videoProfile) const
~PhysicalDevice()
Definition: vulkan_raii.hpp:3071
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:3113
Definition: vulkan_raii.hpp:3486
PhysicalDevices & operator=(PhysicalDevices &&rhs)=default
PhysicalDevices(vk::raii::Instance const &instance)
Definition: vulkan_raii.hpp:3489
PhysicalDevices & operator=(PhysicalDevices const &)=delete
PhysicalDevices(std::nullptr_t)
Definition: vulkan_raii.hpp:3495
PhysicalDevices(PhysicalDevices const &)=delete
PhysicalDevices(PhysicalDevices &&rhs)=default
Definition: vulkan_raii.hpp:9314
void swap(vk::raii::PipelineCache &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:9418
PipelineCache(PipelineCache const &)=delete
VkPipelineCache CType
Definition: vulkan_raii.hpp:9316
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:9385
vk::PipelineCache release()
Definition: vulkan_raii.hpp:9399
PipelineCache(vk::raii::Device const &device, VkPipelineCache pipelineCache, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:9333
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:9412
vk::PipelineCache const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:9375
vk::Device getDevice() const
Definition: vulkan_raii.hpp:9407
PipelineCache(std::nullptr_t)
Definition: vulkan_raii.hpp:9343
PipelineCache(vk::raii::Device const &device, vk::PipelineCacheCreateInfo const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:9325
PipelineCache & operator=(PipelineCache const &)=delete
~PipelineCache()
Definition: vulkan_raii.hpp:9345
PipelineCache(PipelineCache &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:9353
PipelineCache & operator=(PipelineCache &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:9363
Definition: vulkan_raii.hpp:9728
vk::Device getDevice() const
Definition: vulkan_raii.hpp:9821
PipelineLayout(vk::raii::Device const &device, vk::PipelineLayoutCreateInfo const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:9739
PipelineLayout(PipelineLayout &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:9767
PipelineLayout(vk::raii::Device const &device, VkPipelineLayout pipelineLayout, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:9747
vk::PipelineLayout release()
Definition: vulkan_raii.hpp:9813
vk::PipelineLayout const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:9789
VkPipelineLayout CType
Definition: vulkan_raii.hpp:9730
~PipelineLayout()
Definition: vulkan_raii.hpp:9759
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:9826
PipelineLayout & operator=(PipelineLayout const &)=delete
void swap(vk::raii::PipelineLayout &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:9832
PipelineLayout(PipelineLayout const &)=delete
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:9799
PipelineLayout & operator=(PipelineLayout &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:9777
PipelineLayout(std::nullptr_t)
Definition: vulkan_raii.hpp:9757
Definition: vulkan_raii.hpp:9440
Pipeline(vk::raii::Device const &device, vk::Optional< const vk::raii::DeferredOperationKHR > const &deferredOperation, vk::Optional< const vk::raii::PipelineCache > const &pipelineCache, vk::RayTracingPipelineCreateInfoKHR const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:9483
Pipeline(std::nullptr_t)
Definition: vulkan_raii.hpp:9515
Pipeline(vk::raii::Device const &device, VkPipeline pipeline, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr, vk::Result successCode=vk::Result::eSuccess)
Definition: vulkan_raii.hpp:9503
VULKAN_HPP_NODISCARD DataType getRayTracingShaderGroupHandleNV(uint32_t firstGroup, uint32_t groupCount) const
VULKAN_HPP_NODISCARD DataType getRayTracingCaptureReplayShaderGroupHandleKHR(uint32_t firstGroup, uint32_t groupCount) const
VULKAN_HPP_NODISCARD std::vector< DataType > getRayTracingShaderGroupHandlesKHR(uint32_t firstGroup, uint32_t groupCount, size_t dataSize) const
VULKAN_HPP_NODISCARD std::vector< DataType > getRayTracingCaptureReplayShaderGroupHandlesKHR(uint32_t firstGroup, uint32_t groupCount, size_t dataSize) const
Pipeline & operator=(Pipeline const &)=delete
Pipeline(Pipeline const &)=delete
vk::Pipeline release()
Definition: vulkan_raii.hpp:9573
Pipeline(vk::raii::Device const &device, vk::Optional< const vk::raii::PipelineCache > const &pipelineCache, vk::RayTracingPipelineCreateInfoNV const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:9494
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:9592
Pipeline(vk::raii::Device const &device, vk::Optional< const vk::raii::PipelineCache > const &pipelineCache, vk::ExecutionGraphPipelineCreateInfoAMDX const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:9462
Pipeline(Pipeline &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:9525
VULKAN_HPP_NODISCARD std::vector< DataType > getRayTracingShaderGroupHandlesNV(uint32_t firstGroup, uint32_t groupCount, size_t dataSize) const
VkPipeline CType
Definition: vulkan_raii.hpp:9442
~Pipeline()
Definition: vulkan_raii.hpp:9517
vk::Device getDevice() const
Definition: vulkan_raii.hpp:9587
VULKAN_HPP_NODISCARD DataType getRayTracingShaderGroupHandleKHR(uint32_t firstGroup, uint32_t groupCount) const
Pipeline(vk::raii::Device const &device, vk::Optional< const vk::raii::PipelineCache > const &pipelineCache, vk::GraphicsPipelineCreateInfo const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:9473
Pipeline & operator=(Pipeline &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:9536
void swap(vk::raii::Pipeline &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:9598
vk::Pipeline const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:9549
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:9559
Pipeline(vk::raii::Device const &device, vk::Optional< const vk::raii::PipelineCache > const &pipelineCache, vk::ComputePipelineCreateInfo const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:9451
vk::Result getConstructorSuccessCode() const
Definition: vulkan_raii.hpp:9582
Definition: vulkan_raii.hpp:9657
Pipelines(vk::raii::Device const &device, vk::Optional< const vk::raii::PipelineCache > const &pipelineCache, vk::ArrayProxy< vk::RayTracingPipelineCreateInfoNV > const &createInfos, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:9703
Pipelines(Pipelines const &)=delete
Pipelines(std::nullptr_t)
Definition: vulkan_raii.hpp:9712
Pipelines(vk::raii::Device const &device, vk::Optional< const vk::raii::DeferredOperationKHR > const &deferredOperation, vk::Optional< const vk::raii::PipelineCache > const &pipelineCache, vk::ArrayProxy< vk::RayTracingPipelineCreateInfoKHR > const &createInfos, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:9692
Pipelines(Pipelines &&rhs)=default
Pipelines & operator=(Pipelines &&rhs)=default
Pipelines(vk::raii::Device const &device, vk::Optional< const vk::raii::PipelineCache > const &pipelineCache, vk::ArrayProxy< vk::GraphicsPipelineCreateInfo > const &createInfos, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:9682
Pipelines(vk::raii::Device const &device, vk::Optional< const vk::raii::PipelineCache > const &pipelineCache, vk::ArrayProxy< vk::ComputePipelineCreateInfo > const &createInfos, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:9660
Pipelines & operator=(Pipelines const &)=delete
Pipelines(vk::raii::Device const &device, vk::Optional< const vk::raii::PipelineCache > const &pipelineCache, vk::ArrayProxy< vk::ExecutionGraphPipelineCreateInfoAMDX > const &createInfos, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:9671
Definition: vulkan_raii.hpp:9848
~PrivateDataSlot()
Definition: vulkan_raii.hpp:9879
PrivateDataSlot & operator=(PrivateDataSlot &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:9897
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:9919
PrivateDataSlot(vk::raii::Device const &device, VkPrivateDataSlot privateDataSlot, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:9867
PrivateDataSlot(PrivateDataSlot &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:9887
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:9946
PrivateDataSlot(std::nullptr_t)
Definition: vulkan_raii.hpp:9877
VkPrivateDataSlot CType
Definition: vulkan_raii.hpp:9850
PrivateDataSlot(vk::raii::Device const &device, vk::PrivateDataSlotCreateInfo const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:9859
PrivateDataSlot(PrivateDataSlot const &)=delete
vk::Device getDevice() const
Definition: vulkan_raii.hpp:9941
void swap(vk::raii::PrivateDataSlot &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:9952
PrivateDataSlot & operator=(PrivateDataSlot const &)=delete
vk::PrivateDataSlot const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:9909
vk::PrivateDataSlot release()
Definition: vulkan_raii.hpp:9933
Definition: vulkan_raii.hpp:9968
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10039
QueryPool(vk::raii::Device const &device, VkQueryPool queryPool, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:9987
VkQueryPool CType
Definition: vulkan_raii.hpp:9970
vk::QueryPool const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10029
~QueryPool()
Definition: vulkan_raii.hpp:9999
QueryPool & operator=(QueryPool const &)=delete
vk::QueryPool release()
Definition: vulkan_raii.hpp:10052
QueryPool(vk::raii::Device const &device, vk::QueryPoolCreateInfo const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:9979
QueryPool(QueryPool &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10007
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:10065
QueryPool & operator=(QueryPool &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10017
QueryPool(QueryPool const &)=delete
vk::Device getDevice() const
Definition: vulkan_raii.hpp:10060
void swap(vk::raii::QueryPool &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10071
VULKAN_HPP_NODISCARD std::pair< vk::Result, DataType > getResult(uint32_t firstQuery, uint32_t queryCount, vk::DeviceSize stride, vk::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT) const
QueryPool(std::nullptr_t)
Definition: vulkan_raii.hpp:9997
VULKAN_HPP_NODISCARD std::pair< vk::Result, std::vector< DataType > > getResults(uint32_t firstQuery, uint32_t queryCount, size_t dataSize, vk::DeviceSize stride, vk::QueryResultFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT) const
Definition: vulkan_raii.hpp:10112
Queue(vk::raii::Device const &device, vk::DeviceQueueInfo2 const &queueInfo)
Definition: vulkan_raii.hpp:10130
Queue(vk::raii::Device const &device, uint32_t queueFamilyIndex, uint32_t queueIndex)
Definition: vulkan_raii.hpp:10123
vk::Queue release()
Definition: vulkan_raii.hpp:10190
Queue & operator=(Queue const &rhs)
Definition: vulkan_raii.hpp:10157
vk::Queue const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10174
VkQueue CType
Definition: vulkan_raii.hpp:10114
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:10196
void swap(vk::raii::Queue &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10202
~Queue()
Definition: vulkan_raii.hpp:10142
Queue(Queue const &rhs)
Definition: vulkan_raii.hpp:10149
Queue(Queue &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10151
Queue(vk::raii::Device const &device, VkQueue queue)
Definition: vulkan_raii.hpp:10136
Queue & operator=(Queue &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10164
Queue(std::nullptr_t)
Definition: vulkan_raii.hpp:10140
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10184
Definition: vulkan_raii.hpp:10260
RenderPass(RenderPass &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10308
RenderPass & operator=(RenderPass &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10318
RenderPass(vk::raii::Device const &device, vk::RenderPassCreateInfo2 const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:10280
vk::Device getDevice() const
Definition: vulkan_raii.hpp:10361
vk::RenderPass release()
Definition: vulkan_raii.hpp:10353
void swap(vk::raii::RenderPass &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10372
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:10366
VkRenderPass CType
Definition: vulkan_raii.hpp:10262
RenderPass(vk::raii::Device const &device, vk::RenderPassCreateInfo const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:10271
RenderPass & operator=(RenderPass const &)=delete
RenderPass(vk::raii::Device const &device, VkRenderPass renderPass, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:10288
RenderPass(std::nullptr_t)
Definition: vulkan_raii.hpp:10298
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10340
~RenderPass()
Definition: vulkan_raii.hpp:10300
vk::RenderPass const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10330
RenderPass(RenderPass const &)=delete
Definition: vulkan_raii.hpp:10515
vk::Device getDevice() const
Definition: vulkan_raii.hpp:10608
vk::SamplerYcbcrConversion const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10576
~SamplerYcbcrConversion()
Definition: vulkan_raii.hpp:10546
SamplerYcbcrConversion(std::nullptr_t)
Definition: vulkan_raii.hpp:10544
VkSamplerYcbcrConversion CType
Definition: vulkan_raii.hpp:10517
SamplerYcbcrConversion(vk::raii::Device const &device, VkSamplerYcbcrConversion ycbcrConversion, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:10534
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:10613
SamplerYcbcrConversion(SamplerYcbcrConversion &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10554
SamplerYcbcrConversion(vk::raii::Device const &device, vk::SamplerYcbcrConversionCreateInfo const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:10526
vk::SamplerYcbcrConversion release()
Definition: vulkan_raii.hpp:10600
SamplerYcbcrConversion(SamplerYcbcrConversion const &)=delete
void swap(vk::raii::SamplerYcbcrConversion &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10619
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10586
SamplerYcbcrConversion & operator=(SamplerYcbcrConversion &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10564
SamplerYcbcrConversion & operator=(SamplerYcbcrConversion const &)=delete
Definition: vulkan_raii.hpp:10396
Sampler & operator=(Sampler &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10445
VkSampler CType
Definition: vulkan_raii.hpp:10398
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10467
void swap(vk::raii::Sampler &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10499
vk::Sampler release()
Definition: vulkan_raii.hpp:10480
Sampler(vk::raii::Device const &device, vk::SamplerCreateInfo const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:10407
Sampler & operator=(Sampler const &)=delete
~Sampler()
Definition: vulkan_raii.hpp:10427
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:10493
Sampler(Sampler &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10435
vk::Sampler const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10457
Sampler(vk::raii::Device const &device, VkSampler sampler, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:10415
Sampler(Sampler const &)=delete
vk::Device getDevice() const
Definition: vulkan_raii.hpp:10488
Sampler(std::nullptr_t)
Definition: vulkan_raii.hpp:10425
Definition: vulkan_raii.hpp:10635
vk::Semaphore const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10696
Semaphore(Semaphore const &)=delete
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:10732
Semaphore(Semaphore &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10674
Semaphore(vk::raii::Device const &device, vk::SemaphoreCreateInfo const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:10646
~Semaphore()
Definition: vulkan_raii.hpp:10666
Semaphore(std::nullptr_t)
Definition: vulkan_raii.hpp:10664
Semaphore(vk::raii::Device const &device, VkSemaphore semaphore, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:10654
vk::Semaphore release()
Definition: vulkan_raii.hpp:10719
Semaphore & operator=(Semaphore const &)=delete
Semaphore & operator=(Semaphore &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10684
void swap(vk::raii::Semaphore &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10738
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10706
VkSemaphore CType
Definition: vulkan_raii.hpp:10637
vk::Device getDevice() const
Definition: vulkan_raii.hpp:10727
Definition: vulkan_raii.hpp:10762
VkShaderEXT CType
Definition: vulkan_raii.hpp:10764
vk::ShaderEXT const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10823
ShaderEXT & operator=(ShaderEXT &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10811
~ShaderEXT()
Definition: vulkan_raii.hpp:10793
ShaderEXT(vk::raii::Device const &device, VkShaderEXT shader, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:10781
vk::Device getDevice() const
Definition: vulkan_raii.hpp:10854
ShaderEXT(std::nullptr_t)
Definition: vulkan_raii.hpp:10791
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:10859
vk::ShaderEXT release()
Definition: vulkan_raii.hpp:10846
ShaderEXT(vk::raii::Device const &device, vk::ShaderCreateInfoEXT const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:10773
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10833
ShaderEXT(ShaderEXT &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10801
ShaderEXT & operator=(ShaderEXT const &)=delete
void swap(vk::raii::ShaderEXT &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10865
ShaderEXT(ShaderEXT const &)=delete
Definition: vulkan_raii.hpp:10885
ShaderEXTs & operator=(ShaderEXTs &&rhs)=default
ShaderEXTs(ShaderEXTs &&rhs)=default
ShaderEXTs(std::nullptr_t)
Definition: vulkan_raii.hpp:10896
ShaderEXTs(vk::raii::Device const &device, vk::ArrayProxy< vk::ShaderCreateInfoEXT > const &createInfos, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:10888
ShaderEXTs(ShaderEXTs const &)=delete
ShaderEXTs & operator=(ShaderEXTs const &)=delete
Definition: vulkan_raii.hpp:10912
ShaderModule & operator=(ShaderModule &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10961
vk::ShaderModule const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10973
ShaderModule(ShaderModule const &)=delete
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10983
ShaderModule(vk::raii::Device const &device, VkShaderModule shaderModule, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:10931
vk::Device getDevice() const
Definition: vulkan_raii.hpp:11004
ShaderModule(ShaderModule &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:10951
void swap(vk::raii::ShaderModule &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:11015
~ShaderModule()
Definition: vulkan_raii.hpp:10943
ShaderModule & operator=(ShaderModule const &)=delete
ShaderModule(vk::raii::Device const &device, vk::ShaderModuleCreateInfo const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:10923
ShaderModule(std::nullptr_t)
Definition: vulkan_raii.hpp:10941
VkShaderModule CType
Definition: vulkan_raii.hpp:10914
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:11009
vk::ShaderModule release()
Definition: vulkan_raii.hpp:10996
Definition: vulkan_raii.hpp:11035
vk::Instance getInstance() const
Definition: vulkan_raii.hpp:11279
vk::SurfaceKHR release()
Definition: vulkan_raii.hpp:11271
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:11258
SurfaceKHR(vk::raii::Instance const &instance, vk::DisplaySurfaceCreateInfoKHR const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:11068
SurfaceKHR(SurfaceKHR const &)=delete
vk::SurfaceKHR const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:11248
SurfaceKHR & operator=(SurfaceKHR &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:11236
SurfaceKHR(std::nullptr_t)
Definition: vulkan_raii.hpp:11216
~SurfaceKHR()
Definition: vulkan_raii.hpp:11218
vk::raii::InstanceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:11284
SurfaceKHR & operator=(SurfaceKHR const &)=delete
SurfaceKHR(SurfaceKHR &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:11226
void swap(vk::raii::SurfaceKHR &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:11290
VkSurfaceKHR CType
Definition: vulkan_raii.hpp:11037
SurfaceKHR(vk::raii::Instance const &instance, VkSurfaceKHR surface, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:11206
SurfaceKHR(vk::raii::Instance const &instance, vk::HeadlessSurfaceCreateInfoEXT const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:11077
Definition: vulkan_raii.hpp:11306
SwapchainKHR(SwapchainKHR &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:11345
SwapchainKHR & operator=(SwapchainKHR const &)=delete
vk::SwapchainKHR release()
Definition: vulkan_raii.hpp:11390
SwapchainKHR(vk::raii::Device const &device, vk::SwapchainCreateInfoKHR const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:11317
void swap(vk::raii::SwapchainKHR &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:11409
SwapchainKHR(std::nullptr_t)
Definition: vulkan_raii.hpp:11335
~SwapchainKHR()
Definition: vulkan_raii.hpp:11337
SwapchainKHR(SwapchainKHR const &)=delete
SwapchainKHR(vk::raii::Device const &device, VkSwapchainKHR swapchain, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:11325
vk::SwapchainKHR const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:11367
vk::Device getDevice() const
Definition: vulkan_raii.hpp:11398
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:11403
VkSwapchainKHR CType
Definition: vulkan_raii.hpp:11308
SwapchainKHR & operator=(SwapchainKHR &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:11355
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:11377
Definition: vulkan_raii.hpp:11474
SwapchainKHRs(SwapchainKHRs &&rhs)=default
SwapchainKHRs(SwapchainKHRs const &)=delete
SwapchainKHRs(vk::raii::Device const &device, vk::ArrayProxy< vk::SwapchainCreateInfoKHR > const &createInfos, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:11477
SwapchainKHRs & operator=(SwapchainKHRs &&rhs)=default
SwapchainKHRs(std::nullptr_t)
Definition: vulkan_raii.hpp:11485
SwapchainKHRs & operator=(SwapchainKHRs const &)=delete
Definition: vulkan_raii.hpp:11501
vk::ValidationCacheEXT release()
Definition: vulkan_raii.hpp:11586
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:11599
vk::Device getDevice() const
Definition: vulkan_raii.hpp:11594
ValidationCacheEXT(vk::raii::Device const &device, VkValidationCacheEXT validationCache, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:11520
ValidationCacheEXT(ValidationCacheEXT const &)=delete
ValidationCacheEXT(ValidationCacheEXT &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:11540
vk::ValidationCacheEXT const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:11562
void swap(vk::raii::ValidationCacheEXT &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:11605
VkValidationCacheEXT CType
Definition: vulkan_raii.hpp:11503
ValidationCacheEXT & operator=(ValidationCacheEXT const &)=delete
ValidationCacheEXT & operator=(ValidationCacheEXT &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:11550
ValidationCacheEXT(std::nullptr_t)
Definition: vulkan_raii.hpp:11530
ValidationCacheEXT(vk::raii::Device const &device, vk::ValidationCacheCreateInfoEXT const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:11512
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:11572
~ValidationCacheEXT()
Definition: vulkan_raii.hpp:11532
Definition: vulkan_raii.hpp:11627
VideoSessionKHR & operator=(VideoSessionKHR &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:11676
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:11725
vk::VideoSessionKHR const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:11688
VideoSessionKHR(vk::raii::Device const &device, VkVideoSessionKHR videoSession, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:11646
VideoSessionKHR(VideoSessionKHR const &)=delete
VkVideoSessionKHR CType
Definition: vulkan_raii.hpp:11629
void swap(vk::raii::VideoSessionKHR &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:11731
vk::Device getDevice() const
Definition: vulkan_raii.hpp:11720
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:11698
VideoSessionKHR & operator=(VideoSessionKHR const &)=delete
VideoSessionKHR(vk::raii::Device const &device, vk::VideoSessionCreateInfoKHR const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:11638
vk::VideoSessionKHR release()
Definition: vulkan_raii.hpp:11712
~VideoSessionKHR()
Definition: vulkan_raii.hpp:11658
VideoSessionKHR(VideoSessionKHR &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:11666
VideoSessionKHR(std::nullptr_t)
Definition: vulkan_raii.hpp:11656
Definition: vulkan_raii.hpp:11753
VideoSessionParametersKHR(std::nullptr_t)
Definition: vulkan_raii.hpp:11782
vk::VideoSessionParametersKHR release()
Definition: vulkan_raii.hpp:11838
VideoSessionParametersKHR & operator=(VideoSessionParametersKHR const &)=delete
VideoSessionParametersKHR(vk::raii::Device const &device, vk::VideoSessionParametersCreateInfoKHR const &createInfo, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:11764
vk::Device getDevice() const
Definition: vulkan_raii.hpp:11846
VideoSessionParametersKHR & operator=(VideoSessionParametersKHR &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:11802
VkVideoSessionParametersKHR CType
Definition: vulkan_raii.hpp:11755
void swap(vk::raii::VideoSessionParametersKHR &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:11857
VideoSessionParametersKHR(VideoSessionParametersKHR const &)=delete
void clear() VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:11824
VideoSessionParametersKHR(vk::raii::Device const &device, VkVideoSessionParametersKHR videoSessionParameters, vk::Optional< const vk::AllocationCallbacks > allocator=nullptr)
Definition: vulkan_raii.hpp:11772
~VideoSessionParametersKHR()
Definition: vulkan_raii.hpp:11784
vk::VideoSessionParametersKHR const & operator*() const VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:11814
vk::raii::DeviceDispatcher const * getDispatcher() const
Definition: vulkan_raii.hpp:11851
VideoSessionParametersKHR(VideoSessionParametersKHR &&rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan_raii.hpp:11792
Definition: vulkan.hpp:854
VULKAN_HPP_INLINE void throwResultException(Result result, char const *message)
Definition: vulkan.hpp:6541
VULKAN_HPP_CONSTEXPR_14 VULKAN_HPP_INLINE T exchange(T &obj, U &&newValue)
Definition: vulkan_raii.hpp:21
std::vector< typename RAIIType::CppType > filterCppTypes(std::vector< RAIIType > const &raiiTypes, UnaryPredicate p)
Definition: vulkan_raii.hpp:22850
vk::ShaderModule createShaderModule(vk::Device const &device, vk::ShaderStageFlagBits shaderStage, std::string const &shaderText)
Definition: shaders.cpp:88
vk::RenderPass createRenderPass(vk::Device const &device, vk::Format colorFormat, vk::Format depthFormat, vk::AttachmentLoadOp loadOp, vk::ImageLayout colorFinalLayout)
Definition: utils.cpp:314
vk::Pipeline createGraphicsPipeline(vk::Device const &device, vk::PipelineCache const &pipelineCache, std::pair< vk::ShaderModule, vk::SpecializationInfo const * > const &vertexShaderData, std::pair< vk::ShaderModule, vk::SpecializationInfo const * > const &fragmentShaderData, uint32_t vertexStride, std::vector< std::pair< vk::Format, uint32_t >> const &vertexInputAttributeFormatOffset, vk::FrontFace frontFace, bool depthBuffered, vk::PipelineLayout const &pipelineLayout, vk::RenderPass const &renderPass)
Definition: utils.cpp:133
vk::Device createDevice(vk::PhysicalDevice const &physicalDevice, uint32_t queueFamilyIndex, std::vector< std::string > const &extensions, vk::PhysicalDeviceFeatures const *physicalDeviceFeatures, void const *pNext)
Definition: utils.cpp:86
vk::DescriptorSetLayout createDescriptorSetLayout(vk::Device const &device, std::vector< std::tuple< vk::DescriptorType, uint32_t, vk::ShaderStageFlags >> const &bindingData, vk::DescriptorSetLayoutCreateFlags flags)
Definition: utils.cpp:73
void updateDescriptorSets(vk::Device const &device, vk::DescriptorSet const &descriptorSet, std::vector< std::tuple< vk::DescriptorType, vk::Buffer const &, vk::DeviceSize, vk::BufferView const & >> const &bufferData, vk::su::TextureData const &textureData, uint32_t bindingOffset)
Definition: utils.cpp:660
vk::DescriptorPool createDescriptorPool(vk::Device const &device, std::vector< vk::DescriptorPoolSize > const &poolSizes)
Definition: utils.cpp:62
SampleCountFlagBits
Definition: vulkan_enums.hpp:2057
FrontFace
Definition: vulkan_enums.hpp:2803
Flags< CommandBufferResetFlagBits > CommandBufferResetFlags
Definition: vulkan_enums.hpp:3496
SurfaceCounterFlagBitsEXT
Definition: vulkan_enums.hpp:5272
uint32_t SampleMask
Definition: vulkan.hpp:6124
ImageTiling
Definition: vulkan_enums.hpp:1909
Flags< CullModeFlagBits > CullModeFlags
Definition: vulkan_enums.hpp:2701
PrimitiveTopology
Definition: vulkan_enums.hpp:2923
Flags< DebugUtilsMessageTypeFlagBitsEXT > DebugUtilsMessageTypeFlagsEXT
Definition: vulkan_enums.hpp:5518
QueryType
Definition: vulkan_enums.hpp:2343
AccelerationStructureBuildTypeKHR
Definition: vulkan_enums.hpp:5590
Flags< ImageCreateFlagBits > ImageCreateFlags
Definition: vulkan_enums.hpp:1892
OpticalFlowSessionBindingPointNV
Definition: vulkan_enums.hpp:6851
uint64_t DeviceAddress
Definition: vulkan.hpp:6121
Flags< ImageUsageFlagBits > ImageUsageFlags
Definition: vulkan_enums.hpp:1948
Flags< ImageAspectFlagBits > ImageAspectFlags
Definition: vulkan_enums.hpp:2202
PipelineBindPoint
Definition: vulkan_enums.hpp:3401
ImageLayout
Definition: vulkan_enums.hpp:2477
VULKAN_HPP_INLINE void swap(UniqueHandle< Type, Dispatch > &lhs, UniqueHandle< Type, Dispatch > &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:997
Flags< CommandPoolResetFlagBits > CommandPoolResetFlags
Definition: vulkan_enums.hpp:3476
DiscardRectangleModeEXT
Definition: vulkan_enums.hpp:5334
DescriptorType
Definition: vulkan_enums.hpp:3244
Flags< MemoryMapFlagBits > MemoryMapFlags
Definition: vulkan_enums.hpp:2173
VULKAN_HPP_INLINE vk::DebugReportObjectTypeEXT debugReportObjectType(vk::ObjectType objectType)
Definition: vulkan_enums.hpp:7208
Flags< QueryControlFlagBits > QueryControlFlags
Definition: vulkan_enums.hpp:3527
Flags< ExternalMemoryHandleTypeFlagBitsNV > ExternalMemoryHandleTypeFlagsNV
Definition: vulkan_enums.hpp:5182
CoverageModulationModeNV
Definition: vulkan_enums.hpp:5745
PerformanceParameterTypeINTEL
Definition: vulkan_enums.hpp:5874
Flags< PipelineStageFlagBits2 > PipelineStageFlags2
Definition: vulkan_enums.hpp:4134
VULKAN_HPP_INLINE void resultCheck(Result result, char const *message)
Definition: vulkan.hpp:6736
ProvokingVertexModeEXT
Definition: vulkan_enums.hpp:5995
LineRasterizationModeEXT
Definition: vulkan_enums.hpp:6030
DebugReportObjectTypeEXT
Definition: vulkan_enums.hpp:4618
AccelerationStructureCompatibilityKHR
Definition: vulkan_enums.hpp:5695
Flags< DependencyFlagBits > DependencyFlags
Definition: vulkan_enums.hpp:3375
Flags< ShaderStageFlagBits > ShaderStageFlags
Definition: vulkan_enums.hpp:2967
FragmentShadingRateCombinerOpKHR
Definition: vulkan_enums.hpp:5925
Flags< DebugReportFlagBitsEXT > DebugReportFlagsEXT
Definition: vulkan_enums.hpp:4606
ShaderStageFlagBits
Definition: vulkan_enums.hpp:2938
CoarseSampleOrderTypeNV
Definition: vulkan_enums.hpp:5804
DebugUtilsMessageSeverityFlagBitsEXT
Definition: vulkan_enums.hpp:5492
Flags< PeerMemoryFeatureFlagBits > PeerMemoryFeatureFlags
Definition: vulkan_enums.hpp:3606
TessellationDomainOrigin
Definition: vulkan_enums.hpp:3658
CopyAccelerationStructureModeKHR
Definition: vulkan_enums.hpp:5678
ExternalMemoryHandleTypeFlagBits
Definition: vulkan_enums.hpp:3710
PipelineStageFlagBits
Definition: vulkan_enums.hpp:2115
uint32_t Bool32
Definition: vulkan.hpp:6120
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result enumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pPropertyCount, vk::ExtensionProperties *pProperties, Dispatch const &d) VULKAN_HPP_NOEXCEPT
Definition: vulkan_funcs.hpp:508
Flags< QueryResultFlagBits > QueryResultFlags
Definition: vulkan_enums.hpp:2331
Filter
Definition: vulkan_enums.hpp:3152
ImageType
Definition: vulkan_enums.hpp:1916
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result createInstance(const vk::InstanceCreateInfo *pCreateInfo, const vk::AllocationCallbacks *pAllocator, vk::Instance *pInstance, Dispatch const &d) VULKAN_HPP_NOEXCEPT
Definition: vulkan_funcs.hpp:21
LogicOp
Definition: vulkan_enums.hpp:2809
ConservativeRasterizationModeEXT
Definition: vulkan_enums.hpp:5355
Flags< PipelineStageFlagBits > PipelineStageFlags
Definition: vulkan_enums.hpp:2151
SubpassContents
Definition: vulkan_enums.hpp:3564
PolygonMode
Definition: vulkan_enums.hpp:2915
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result enumerateInstanceVersion(uint32_t *pApiVersion, Dispatch const &d) VULKAN_HPP_NOEXCEPT
Definition: vulkan_funcs.hpp:5722
uint64_t DeviceSize
Definition: vulkan.hpp:6122
Result
Definition: vulkan_enums.hpp:231
FragmentShadingRateNV
Definition: vulkan_enums.hpp:6395
CoverageReductionModeNV
Definition: vulkan_enums.hpp:5974
MemoryRequirements2 MemoryRequirements2KHR
Definition: vulkan_handles.hpp:167
CompareOp
Definition: vulkan_enums.hpp:2682
PresentModeKHR
Definition: vulkan_enums.hpp:4374
IndexType
Definition: vulkan_enums.hpp:3537
PipelineInfoKHR PipelineInfoEXT
Definition: vulkan_handles.hpp:1143
Flags< DeviceGroupPresentModeFlagBitsKHR > DeviceGroupPresentModeFlagsKHR
Definition: vulkan_enums.hpp:4452
Flags< CommandPoolTrimFlagBits > CommandPoolTrimFlags
Definition: vulkan_enums.hpp:3640
ObjectType
Definition: vulkan_enums.hpp:1412
Format
Definition: vulkan_enums.hpp:1485
Flags< StencilFaceFlagBits > StencilFaceFlags
Definition: vulkan_enums.hpp:3553
void * RemoteAddressNV
Definition: vulkan.hpp:6123
Flags< DescriptorPoolResetFlagBits > DescriptorPoolResetFlags
Definition: vulkan_enums.hpp:3270
ShaderInfoTypeAMD
Definition: vulkan_enums.hpp:5149
ShaderGroupShaderKHR
Definition: vulkan_enums.hpp:5735
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result enumerateInstanceLayerProperties(uint32_t *pPropertyCount, vk::LayerProperties *pProperties, Dispatch const &d) VULKAN_HPP_NOEXCEPT
Definition: vulkan_funcs.hpp:672
StencilOp
Definition: vulkan_enums.hpp:2982
void(*)() PFN_dummy
Definition: vulkan.hpp:16389
Definition: vulkan_core.h:18926
Definition: vulkan_core.h:18879
Definition: vulkan_core.h:19017
Definition: vulkan_core.h:18940
Definition: vulkan_core.h:13472
Definition: vulkan_core.h:18981
Definition: vulkan_core.h:13462
Definition: vulkan_core.h:18987
Definition: vulkan_core.h:7694
Definition: vulkan_core.h:9533
Definition: vulkan_core.h:2926
Definition: vulkan_core.h:2822
Definition: vulkan_core.h:13479
Definition: vulkan_core.h:5062
Definition: vulkan_core.h:11403
Definition: vulkan_core.h:11351
Definition: vulkan_core.h:5070
Definition: vulkan_core.h:3289
Definition: vulkan_core.h:8094
Definition: vulkan_core.h:7062
Definition: vulkan_core.h:15833
Definition: vulkan_core.h:3830
Definition: vulkan_core.h:3345
Definition: vulkan_core.h:6365
Definition: vulkan_core.h:3843
Definition: vulkan_core.h:2827
VkDeviceSize size
Definition: vulkan_core.h:2836
Definition: vulkan_core.h:5171
Definition: vulkan_core.h:3356
Definition: vulkan_core.h:11303
Definition: vulkan_core.h:10713
Definition: vulkan_core.h:14027
Definition: vulkan_core.h:3868
Definition: vulkan_core.h:3858
Definition: vulkan_core.h:3874
Definition: vulkan_core.h:13241
Definition: vulkan_core.h:17764
Definition: vulkan_core.h:17755
Definition: vulkan_core.h:3804
Definition: vulkan_core.h:3823
Definition: vulkan_core.h:3797
Definition: vulkan_core.h:3449
Definition: vulkan_core.h:12183
Definition: vulkan_core.h:11198
Definition: vulkan_core.h:14492
Definition: vulkan_core.h:19009
Definition: vulkan_core.h:18993
Definition: vulkan_core.h:6992
Definition: vulkan_core.h:7033
Definition: vulkan_core.h:3658
Definition: vulkan_core.h:7011
Definition: vulkan_core.h:7043
Definition: vulkan_core.h:14905
Definition: vulkan_core.h:14895
Definition: vulkan_core.h:19001
Definition: vulkan_core.h:14885
Definition: vulkan_core.h:17045
Definition: vulkan_core.h:17053
Definition: vulkan_core.h:17037
Definition: vulkan_core.h:11792
Definition: vulkan_core.h:11799
Definition: vulkan_core.h:11785
Definition: vulkan_core.h:15643
Definition: vulkan_core.h:15650
Definition: vulkan_core.h:15636
Definition: vulkan_core.h:11625
Definition: vulkan_core.h:11607
Definition: vulkan_core.h:11615
Definition: vulkan_core.h:11519
Definition: vulkan_core.h:12675
Definition: vulkan_core.h:12690
Definition: vulkan_core.h:12711
Definition: vulkan_core.h:12682
Definition: vulkan_core.h:12721
Definition: vulkan_core.h:17526
Definition: vulkan_core.h:6926
Definition: vulkan_core.h:15374
Definition: vulkan_core.h:15800
Definition: vulkan_core.h:15826
Definition: vulkan_core.h:3687
Definition: vulkan_core.h:3696
Definition: vulkan_core.h:17346
Definition: vulkan_core.h:3712
Definition: vulkan_core.h:17353
Definition: vulkan_core.h:5527
Definition: vulkan_core.h:5407
Definition: vulkan_core.h:7277
Definition: vulkan_core.h:3190
Definition: vulkan_core.h:12322
Definition: vulkan_core.h:16313
Definition: vulkan_core.h:16333
Definition: vulkan_core.h:7704
Definition: vulkan_core.h:7283
Definition: vulkan_core.h:11088
Definition: vulkan_core.h:6383
Definition: vulkan_core.h:5341
Definition: vulkan_core.h:12328
Definition: vulkan_core.h:7809
Definition: vulkan_core.h:9660
Definition: vulkan_core.h:7816
Definition: vulkan_core.h:9673
Definition: vulkan_core.h:7821
Definition: vulkan_core.h:9666
Definition: vulkan_core.h:9654
Definition: vulkan_core.h:7833
Definition: vulkan_core.h:12316
Definition: vulkan_core.h:9648
Definition: vulkan_core.h:7838
Definition: vulkan_core.h:7848
Definition: vulkan_core.h:3330
Definition: vulkan_core.h:3203
Definition: vulkan_core.h:2790
Definition: vulkan_core.h:5446
Definition: vulkan_core.h:5486
Definition: vulkan_core.h:12030
Definition: vulkan_core.h:5512
Definition: vulkan_core.h:3318
Definition: vulkan_core.h:9410
Definition: vulkan_core.h:5213
Definition: vulkan_core.h:2945
Definition: vulkan_core.h:3750
Definition: vulkan_core.h:14552
Definition: vulkan_core.h:15233
Definition: vulkan_core.h:15251
Definition: vulkan_core.h:18621
Definition: vulkan_core.h:3599
Definition: vulkan_core.h:12601
Definition: vulkan_core.h:14634
Definition: vulkan_core.h:14917
Definition: vulkan_core.h:3880
Definition: vulkan_core.h:15839
Definition: vulkan_core.h:3887
Definition: vulkan_core.h:3366
Definition: vulkan_core.h:13068
Definition: vulkan_core.h:5219
Definition: vulkan_core.h:2951
Definition: vulkan_core.h:2868
Definition: vulkan_core.h:5177
Definition: vulkan_core.h:3895
Definition: vulkan_core.h:5183
Definition: vulkan_core.h:11082
Definition: vulkan_core.h:3836
Definition: vulkan_core.h:2860
Definition: vulkan_core.h:3268
Definition: vulkan_core.h:11863
Definition: vulkan_core.h:15845
Definition: vulkan_core.h:3399
Definition: vulkan_core.h:11855
Definition: vulkan_core.h:9401
Definition: vulkan_core.h:9138
Definition: vulkan_core.h:15222
Definition: vulkan_core.h:14110
Definition: vulkan_core.h:2959
Definition: vulkan_core.h:18588
Definition: vulkan_core.h:18580
Definition: vulkan_core.h:3208
Definition: vulkan_core.h:3227
Definition: vulkan_core.h:3235
Definition: vulkan_core.h:2881
Definition: vulkan_core.h:9066
Definition: vulkan_core.h:9072
Definition: vulkan_core.h:16607
Definition: vulkan_core.h:13723
Definition: vulkan_core.h:10423
Definition: vulkan_core.h:5189
Definition: vulkan_core.h:3242
Definition: vulkan_core.h:10432
Definition: vulkan_core.h:16989
Definition: vulkan_core.h:17061
Definition: vulkan_core.h:17005
Definition: vulkan_core.h:17031
Definition: vulkan_core.h:16847
Definition: vulkan_core.h:16842
Definition: vulkan_core.h:12897
Definition: vulkan_core.h:18204
Definition: vulkan_core.h:18170
Definition: vulkan_core.h:18176
Definition: vulkan_core.h:18182
Definition: vulkan_core.h:18640
Definition: vulkan_core.h:12380
Definition: vulkan_core.h:14144
Definition: vulkan_core.h:9507
Definition: vulkan_core.h:9498
Definition: vulkan_core.h:14124
Definition: vulkan_core.h:14136
Definition: vulkan_core.h:14130
Definition: vulkan_core.h:14105
Definition: vulkan_core.h:5438
Definition: vulkan_core.h:5480
Definition: vulkan_core.h:5506
Definition: vulkan_core.h:5201
Definition: vulkan_core.h:2980
Definition: vulkan_core.h:10176
Definition: vulkan_core.h:5156
Definition: vulkan_core.h:5225
Definition: vulkan_core.h:5241
Definition: vulkan_core.h:3147
Definition: vulkan_core.h:5207
Definition: vulkan_core.h:3162
Definition: vulkan_core.h:5253
Definition: vulkan_core.h:9599
Definition: vulkan_core.h:6848
Definition: vulkan_core.h:10620
Definition: vulkan_core.h:8054
Definition: vulkan_core.h:3418
Definition: vulkan_core.h:10360
Definition: vulkan_core.h:10383
Definition: vulkan_core.h:10351
Definition: vulkan_core.h:10374
Definition: vulkan_core.h:17584
Definition: vulkan_core.h:10345
Definition: vulkan_core.h:3627
Definition: vulkan_core.h:7670
Definition: vulkan_core.h:6876
Definition: vulkan_core.h:11363
Definition: vulkan_core.h:11373
Definition: vulkan_core.h:11383
Definition: vulkan_core.h:3336
Definition: vulkan_core.h:9516
Definition: vulkan_core.h:5235
Definition: vulkan_core.h:3174
Definition: vulkan_core.h:19167
Definition: vulkan_core.h:13410
Definition: vulkan_core.h:2812
Definition: vulkan_core.h:12376
Definition: vulkan_core.h:15082
Definition: vulkan_core.h:3903
Definition: vulkan_core.h:6043
Definition: vulkan_core.h:3785
Definition: vulkan_core.h:11072
Definition: vulkan_core.h:7166
Definition: vulkan_core.h:7084
Definition: vulkan_core.h:12852
Definition: vulkan_core.h:15851
Definition: vulkan_core.h:3637
Definition: vulkan_core.h:5355
Definition: vulkan_core.h:3324
Definition: vulkan_core.h:9147
Definition: vulkan_core.h:6350
Definition: vulkan_core.h:6341
Definition: vulkan_core.h:11392
Definition: vulkan_core.h:18595
Definition: vulkan_core.h:18310
Definition: vulkan_core.h:3410
Definition: vulkan_core.h:18056
Definition: vulkan_core.h:13207
Definition: vulkan_core.h:5247
Definition: vulkan_core.h:3304
Definition: vulkan_core.h:5195
Definition: vulkan_core.h:3310
Definition: vulkan_core.h:19207
Definition: vulkan_core.h:6954
Definition: vulkan_core.h:3215
Definition: vulkan_core.h:6057
Definition: vulkan_core.h:6063
Definition: vulkan_core.h:11095
Definition: vulkan_core.h:3384
Definition: vulkan_core.h:12269
Definition: vulkan_core.h:9605
Definition: vulkan_core.h:7571
Definition: vulkan_core.h:9611
Definition: vulkan_core.h:7584
Definition: vulkan_core.h:7649
Definition: vulkan_core.h:18371
Definition: vulkan_core.h:13108
Definition: vulkan_core.h:16443
Definition: vulkan_core.h:16434
Definition: vulkan_core.h:8131
Definition: vulkan_core.h:8040
Definition: vulkan_core.h:8147
Definition: vulkan_core.h:8264
Definition: vulkan_core.h:10560
Definition: vulkan_core.h:10627
Definition: vulkan_core.h:10646
Definition: vulkan_core.h:10640
Definition: vulkan_core.h:8141
Definition: vulkan_core.h:8060
Definition: vulkan_core.h:8024
Definition: vulkan_core.h:8103
Definition: vulkan_core.h:8087
Definition: vulkan_core.h:8117
Definition: vulkan_core.h:8125
Definition: vulkan_core.h:12466
Definition: vulkan_core.h:12221
Definition: vulkan_core.h:3497
Definition: vulkan_core.h:3720
Definition: vulkan_structs.hpp:723
Definition: vulkan_structs.hpp:949
Definition: vulkan_structs.hpp:1055
Definition: vulkan_structs.hpp:2150
Definition: vulkan_structs.hpp:2259
Definition: vulkan_structs.hpp:2791
Definition: vulkan_structs.hpp:4171
Definition: vulkan_structs.hpp:4267
Definition: vulkan_structs.hpp:4513
Definition: vulkan_structs.hpp:7112
Definition: vulkan_structs.hpp:7404
Definition: vulkan_structs.hpp:7525
Definition: vulkan_structs.hpp:7645
Definition: vulkan_structs.hpp:8176
Definition: vulkan_structs.hpp:10543
Definition: vulkan_structs.hpp:11618
Definition: vulkan_structs.hpp:12224
Definition: vulkan_structs.hpp:12942
Definition: vulkan_structs.hpp:13235
Definition: vulkan_structs.hpp:13375
Definition: vulkan_structs.hpp:13474
Definition: vulkan_structs.hpp:13556
Definition: vulkan_structs.hpp:14223
Definition: vulkan_structs.hpp:14342
Definition: vulkan_structs.hpp:14471
Definition: vulkan_structs.hpp:15615
Definition: vulkan_structs.hpp:16105
Definition: vulkan_structs.hpp:16366
Definition: vulkan_structs.hpp:16938
Definition: vulkan_structs.hpp:17058
Definition: vulkan_structs.hpp:17161
Definition: vulkan_structs.hpp:17309
Definition: vulkan_structs.hpp:17575
Definition: vulkan_structs.hpp:17872
Definition: vulkan_structs.hpp:18048
Definition: vulkan_structs.hpp:18216
Definition: vulkan_structs.hpp:18559
Definition: vulkan_structs.hpp:18821
Definition: vulkan_structs.hpp:19207
Definition: vulkan_structs.hpp:19373
Definition: vulkan_structs.hpp:19474
Definition: vulkan_structs.hpp:19592
Definition: vulkan_structs.hpp:19693
Definition: vulkan_structs.hpp:19807
Definition: vulkan_structs.hpp:20064
Definition: vulkan_structs.hpp:20187
Definition: vulkan_structs.hpp:20851
Definition: vulkan_structs.hpp:20966
Definition: vulkan_structs.hpp:21098
Definition: vulkan_structs.hpp:21376
Definition: vulkan_structs.hpp:21616
Definition: vulkan_structs.hpp:21488
Definition: vulkan_structs.hpp:22033
Definition: vulkan_structs.hpp:22200
Definition: vulkan_structs.hpp:23071
Definition: vulkan_structs.hpp:24330
Definition: vulkan_structs.hpp:24580
Definition: vulkan_structs.hpp:24719
Definition: vulkan_structs.hpp:25097
Definition: vulkan_structs.hpp:25237
Definition: vulkan_structs.hpp:25342
Definition: vulkan_structs.hpp:25767
Definition: vulkan_structs.hpp:26114
Definition: vulkan_structs.hpp:27076
Definition: vulkan_structs.hpp:27555
Definition: vulkan_structs.hpp:28613
Definition: vulkan_structs.hpp:29562
Definition: vulkan_structs.hpp:29772
Definition: vulkan_structs.hpp:29882
Definition: vulkan_structs.hpp:30435
Definition: vulkan_structs.hpp:31274
Definition: vulkan_structs.hpp:31639
Definition: vulkan_structs.hpp:32097
Definition: vulkan_structs.hpp:32253
Definition: vulkan_structs.hpp:32468
Definition: vulkan_structs.hpp:33586
Definition: vulkan_structs.hpp:35825
Definition: vulkan_structs.hpp:6543
Definition: vulkan_structs.hpp:35978
Definition: vulkan_structs.hpp:36063
Definition: vulkan_structs.hpp:37004
Definition: vulkan_structs.hpp:37100
Definition: vulkan_structs.hpp:37574
Definition: vulkan_structs.hpp:37498
Definition: vulkan_structs.hpp:38416
Definition: vulkan_structs.hpp:39075
Definition: vulkan_structs.hpp:41573
Definition: vulkan_structs.hpp:42417
Definition: vulkan_structs.hpp:42779
Definition: vulkan_structs.hpp:29287
Definition: vulkan_structs.hpp:44299
Definition: vulkan_structs.hpp:44507
Definition: vulkan_structs.hpp:36437
Definition: vulkan_structs.hpp:44761
Definition: vulkan_structs.hpp:45334
Definition: vulkan_structs.hpp:29674
Definition: vulkan_structs.hpp:10309
Definition: vulkan_structs.hpp:9190
Definition: vulkan_structs.hpp:45908
Definition: vulkan_structs.hpp:46058
Definition: vulkan_structs.hpp:48873
Definition: vulkan_structs.hpp:49064
Definition: vulkan_structs.hpp:49917
Definition: vulkan_structs.hpp:50380
Definition: vulkan_structs.hpp:51704
Definition: vulkan_structs.hpp:51786
Definition: vulkan_structs.hpp:52180
Definition: vulkan_structs.hpp:52332
Definition: vulkan_structs.hpp:52717
Definition: vulkan_structs.hpp:52956
Definition: vulkan_structs.hpp:53319
Definition: vulkan_structs.hpp:53415
Definition: vulkan_structs.hpp:53509
Definition: vulkan_structs.hpp:54365
Definition: vulkan_structs.hpp:54683
Definition: vulkan_structs.hpp:54983
Definition: vulkan_structs.hpp:55163
Definition: vulkan_structs.hpp:56014
Definition: vulkan_structs.hpp:64255
Definition: vulkan_structs.hpp:64378
Definition: vulkan_structs.hpp:65067
Definition: vulkan_structs.hpp:65276
Definition: vulkan_structs.hpp:68550
Definition: vulkan_structs.hpp:72409
Definition: vulkan_structs.hpp:72325
Definition: vulkan_structs.hpp:77262
Definition: vulkan_structs.hpp:77158
Definition: vulkan_structs.hpp:84182
Definition: vulkan_structs.hpp:85796
Definition: vulkan_structs.hpp:89929
Definition: vulkan_structs.hpp:91424
Definition: vulkan_structs.hpp:91530
Definition: vulkan_structs.hpp:91645
Definition: vulkan_structs.hpp:91806
Definition: vulkan_structs.hpp:92126
Definition: vulkan_structs.hpp:92237
Definition: vulkan_structs.hpp:92424
Definition: vulkan_structs.hpp:96627
Definition: vulkan_structs.hpp:96821
Definition: vulkan_structs.hpp:97219
Definition: vulkan_structs.hpp:97386
Definition: vulkan_structs.hpp:97613
Definition: vulkan_structs.hpp:98455
Definition: vulkan_structs.hpp:98375
Definition: vulkan_structs.hpp:98967
Definition: vulkan_structs.hpp:99388
Definition: vulkan_structs.hpp:7927
Definition: vulkan_structs.hpp:99682
Definition: vulkan_structs.hpp:99946
Definition: vulkan_structs.hpp:101177
Definition: vulkan_structs.hpp:100502
Definition: vulkan_structs.hpp:103139
Definition: vulkan_structs.hpp:103693
Definition: vulkan_structs.hpp:103896
Definition: vulkan_structs.hpp:104391
Definition: vulkan_structs.hpp:104949
Definition: vulkan_structs.hpp:105762
Definition: vulkan_structs.hpp:106193
Definition: vulkan_structs.hpp:106407
Definition: vulkan_structs.hpp:106577
Definition: vulkan_structs.hpp:106955
Definition: vulkan_structs.hpp:107270
Definition: vulkan_structs.hpp:107407
Definition: vulkan_structs.hpp:107932
Definition: vulkan_structs.hpp:107856
Definition: vulkan_structs.hpp:108105
Definition: vulkan_structs.hpp:108017
Definition: vulkan_structs.hpp:108633
Definition: vulkan_structs.hpp:108852
Definition: vulkan_structs.hpp:109074
Definition: vulkan_structs.hpp:109537
Definition: vulkan_structs.hpp:43913
Definition: vulkan_structs.hpp:109763
Definition: vulkan_structs.hpp:110163
Definition: vulkan_structs.hpp:111074
Definition: vulkan_structs.hpp:112265
Definition: vulkan_structs.hpp:112885
Definition: vulkan_structs.hpp:113926
Definition: vulkan_structs.hpp:114226
Definition: vulkan_structs.hpp:115902
Definition: vulkan_structs.hpp:121131
Definition: vulkan_structs.hpp:121214
Definition: vulkan_structs.hpp:121434
Definition: vulkan_structs.hpp:121877
Definition: vulkan_structs.hpp:122156
Definition: vulkan_structs.hpp:95187
Definition: vulkan_structs.hpp:95435
Definition: vulkan_structs.hpp:15267
Definition: vulkan_structs.hpp:96988
Definition: vulkan_core.h:3852
module
Definition: vulkan.cppm:11
void(* PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR)(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR *pPerformanceQueryCreateInfo, uint32_t *pNumPasses)
Definition: vulkan_core.h:9547
VkResult(* PFN_vkBuildAccelerationStructuresKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR *const *ppBuildRangeInfos)
Definition: vulkan_core.h:19029
void(* PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT)(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize)
Definition: vulkan_core.h:17785
VkResult vkGetPipelineExecutablePropertiesKHR(VkDevice device, const VkPipelineInfoKHR *pPipelineInfo, uint32_t *pExecutableCount, VkPipelineExecutablePropertiesKHR *pProperties)
uint32_t(* PFN_vkGetImageViewHandleNVX)(VkDevice device, const VkImageViewHandleInfoNVX *pInfo)
Definition: vulkan_core.h:11870
VkResult vkDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT *pTagInfo)
VkResult(* PFN_vkDebugMarkerSetObjectNameEXT)(VkDevice device, const VkDebugMarkerObjectNameInfoEXT *pNameInfo)
Definition: vulkan_core.h:11633
void(* PFN_vkDestroyCuFunctionNVX)(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:11819
void(* PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties)
Definition: vulkan_core.h:3920
void(* PFN_vkGetImageMemoryRequirements2)(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:5548
void(* PFN_vkDestroyDescriptorUpdateTemplate)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:5563
void vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties)
void(* PFN_vkGetDeviceBufferMemoryRequirements)(VkDevice device, const VkDeviceBufferMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:7324
void vkCmdControlVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR *pCodingControlInfo)
void vkCmdCopyBufferToImage2(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 *pCopyBufferToImageInfo)
VkResult(* PFN_vkUnmapMemory2KHR)(VkDevice device, const VkMemoryUnmapInfoKHR *pMemoryUnmapInfo)
Definition: vulkan_core.h:10440
void(* PFN_vkGetPhysicalDeviceSparseImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
Definition: vulkan_core.h:5557
VkResult(* PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence *pFences)
Definition: vulkan_core.h:3950
void(* PFN_vkDestroySamplerYcbcrConversion)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:5561
void(* PFN_vkCmdDispatchBase)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
Definition: vulkan_core.h:5546
void(* PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT)(VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask)
Definition: vulkan_core.h:18822
VkResult(* PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT *pInfo, void *pData)
Definition: vulkan_core.h:15878
void(* PFN_vkCmdBuildAccelerationStructureNV)(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV *pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset)
Definition: vulkan_core.h:13548
void(* PFN_vkCmdSetStencilTestEnable)(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable)
Definition: vulkan_core.h:7319
VkResult vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t *pDataSize, void *pData)
uint64_t VkVideoSessionParametersKHR
Definition: vulkan_core.h:7946
void vkCmdTraceRaysIndirect2KHR(VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress)
void vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
void(* PFN_vkQueueNotifyOutOfBandNV)(VkQueue queue, const VkOutOfBandQueueTypeInfoNV *pQueueTypeInfo)
Definition: vulkan_core.h:18657
void(* PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
Definition: vulkan_core.h:4033
void(* PFN_vkCmdDrawIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
Definition: vulkan_core.h:6389
void(* PFN_vkSetLatencyMarkerNV)(VkDevice device, VkSwapchainKHR swapchain, const VkSetLatencyMarkerInfoNV *pLatencyMarkerInfo)
Definition: vulkan_core.h:18655
uint64_t VkImage
Definition: vulkan_core.h:100
VkFlags VkPipelineStageFlags
Definition: vulkan_core.h:2405
void vkCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
void vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize *pCommittedMemoryInBytes)
VkResult(* PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule)
Definition: vulkan_core.h:3972
VkResult(* PFN_vkGetEncodedVideoSessionParametersKHR)(VkDevice device, const VkVideoEncodeSessionParametersGetInfoKHR *pVideoSessionParametersInfo, VkVideoEncodeSessionParametersFeedbackInfoKHR *pFeedbackInfo, size_t *pDataSize, void *pData)
Definition: vulkan_core.h:10653
void(* PFN_vkCmdCopyBufferToImage2)(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 *pCopyBufferToImageInfo)
Definition: vulkan_core.h:7303
void(* PFN_vkGetAccelerationStructureMemoryRequirementsNV)(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2KHR *pMemoryRequirements)
Definition: vulkan_core.h:13546
void(* PFN_vkCmdSetDepthTestEnable)(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable)
Definition: vulkan_core.h:7315
void vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites)
VkResult(* PFN_vkEnumerateInstanceExtensionProperties)(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties)
Definition: vulkan_core.h:3926
void(* PFN_vkCmdSetDepthBoundsTestEnable)(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable)
Definition: vulkan_core.h:7318
void(* PFN_vkCmdSetViewportWScalingEnableNV)(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable)
Definition: vulkan_core.h:17793
VkResult(* PFN_vkGetVideoSessionMemoryRequirementsKHR)(VkDevice device, VkVideoSessionKHR videoSession, uint32_t *pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR *pMemoryRequirements)
Definition: vulkan_core.h:8157
void vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, const VkDependencyInfo *pDependencyInfos)
void(* PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3966
void(* PFN_vkCmdResetEvent2)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask)
Definition: vulkan_core.h:7296
VkResult vkCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
VkResult(* PFN_vkWriteMicromapsPropertiesEXT)(VkDevice device, uint32_t micromapCount, const VkMicromapEXT *pMicromaps, VkQueryType queryType, size_t dataSize, void *pData, size_t stride)
Definition: vulkan_core.h:17095
VkResult(* PFN_vkCreateDeferredOperationKHR)(VkDevice device, const VkAllocationCallbacks *pAllocator, VkDeferredOperationKHR *pDeferredOperation)
Definition: vulkan_core.h:10296
void(* PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
Definition: vulkan_core.h:4017
void(* PFN_vkCmdDecompressMemoryIndirectCountNV)(VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride)
Definition: vulkan_core.h:17548
void vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes, const VkDeviceSize *pStrides)
void(* PFN_vkSetLocalDimmingAMD)(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable)
Definition: vulkan_core.h:14231
uint64_t VkSurfaceKHR
Definition: vulkan_core.h:7513
void(* PFN_vkCmdEndRenderingKHR)(VkCommandBuffer commandBuffer)
Definition: vulkan_core.h:8821
VkResult(* PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV)(VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV *pOpticalFlowImageFormatInfo, uint32_t *pFormatCount, VkOpticalFlowImageFormatPropertiesNV *pImageFormatProperties)
Definition: vulkan_core.h:18212
void(* PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter)
Definition: vulkan_core.h:4027
uint64_t VkShaderModule
Definition: vulkan_core.h:113
void vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes)
void(* PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
Definition: vulkan_core.h:4023
void vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace)
void(* PFN_vkCmdBindShadersEXT)(VkCommandBuffer commandBuffer, uint32_t stageCount, const VkShaderStageFlagBits *pStages, const VkShaderEXT *pShaders)
Definition: vulkan_core.h:18332
uint64_t VkQueryPool
Definition: vulkan_core.h:110
void vkDestroyCuModuleNVX(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks *pAllocator)
void(* PFN_vkCmdSetExclusiveScissorEnableNV)(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkBool32 *pExclusiveScissorEnables)
Definition: vulkan_core.h:13999
VkResult vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR *pQualityLevelInfo, VkVideoEncodeQualityLevelPropertiesKHR *pQualityLevelProperties)
VkResult vkGetPhysicalDeviceOpticalFlowImageFormatsNV(VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV *pOpticalFlowImageFormatInfo, uint32_t *pFormatCount, VkOpticalFlowImageFormatPropertiesNV *pImageFormatProperties)
void vkCmdBuildAccelerationStructuresKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR *const *ppBuildRangeInfos)
VkResult(* PFN_vkCreateInstance)(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance)
Definition: vulkan_core.h:3913
void vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
void vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers)
void vkDestroyVideoSessionKHR(VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks *pAllocator)
VkResult(* PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages)
Definition: vulkan_core.h:7727
void vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator)
VkResult(* PFN_vkQueueWaitIdle)(VkQueue queue)
Definition: vulkan_core.h:3932
void vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers)
VkResult(* PFN_vkGetRayTracingShaderGroupHandlesKHR)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
Definition: vulkan_core.h:13552
void vkCmdWriteAccelerationStructuresPropertiesKHR(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
VkResult vkUnmapMemory2KHR(VkDevice device, const VkMemoryUnmapInfoKHR *pMemoryUnmapInfo)
void(* PFN_vkQueueInsertDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
Definition: vulkan_core.h:12735
void(* PFN_vkCmdSetStencilTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable)
Definition: vulkan_core.h:14771
void vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties)
uint64_t VkMicromapEXT
Definition: vulkan_core.h:16913
VkResult vkBuildAccelerationStructuresKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR *const *ppBuildRangeInfos)
void vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator)
void vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolveImageInfo2 *pResolveImageInfo)
void vkSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR *pSwapchains, const VkHdrMetadataEXT *pMetadata)
void(* PFN_vkGetPhysicalDeviceFormatProperties2)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
Definition: vulkan_core.h:5553
uint64_t VkIndirectCommandsLayoutNV
Definition: vulkan_core.h:15109
void(* PFN_vkCmdResetEvent2KHR)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask)
Definition: vulkan_core.h:10721
void(* PFN_vkGetDeviceMicromapCompatibilityEXT)(VkDevice device, const VkMicromapVersionInfoEXT *pVersionInfo, VkAccelerationStructureCompatibilityKHR *pCompatibility)
Definition: vulkan_core.h:17100
VkImageLayout
Definition: vulkan_core.h:1282
void(* PFN_vkCmdSetPrimitiveTopology)(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology)
Definition: vulkan_core.h:7311
VkResult vkGetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t *pPropertyCount, VkDisplayModeProperties2KHR *pProperties)
void vkCmdSetConservativeRasterizationModeEXT(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode)
VkResult(* PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
Definition: vulkan_core.h:4005
void(* PFN_vkCmdSetStencilOp)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp)
Definition: vulkan_core.h:7320
void(* PFN_vkCmdBeginDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
Definition: vulkan_core.h:12736
void vkGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
void vkDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
void vkDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks *pAllocator)
VkResult vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
void(* PFN_vkCmdSetLineRasterizationModeEXT)(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode)
Definition: vulkan_core.h:17790
void(* PFN_vkDestroyDeferredOperationKHR)(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:10297
void(* PFN_vkCmdWriteMicromapsPropertiesEXT)(VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT *pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
Definition: vulkan_core.h:17099
VkResult vkGetPhysicalDeviceVideoFormatPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR *pVideoFormatInfo, uint32_t *pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR *pVideoFormatProperties)
void vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2 *pCopyImageInfo)
VkIndexType
Definition: vulkan_core.h:2129
void(* PFN_vkGetPhysicalDeviceProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties)
Definition: vulkan_core.h:5552
void(* PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3956
VkResult(* PFN_vkGetShaderBinaryDataEXT)(VkDevice device, VkShaderEXT shader, size_t *pDataSize, void *pData)
Definition: vulkan_core.h:18331
void vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
void vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions)
VkResult(* PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
Definition: vulkan_core.h:7867
VkResult(* PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainKHR *pTimeDomains)
Definition: vulkan_core.h:13787
void vkCmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX *pLaunchInfo)
VkResult(* PFN_vkGetSemaphoreCounterValueKHR)(VkDevice device, VkSemaphore semaphore, uint64_t *pValue)
Definition: vulkan_core.h:10082
void vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets)
void vkGetDeviceImageMemoryRequirementsKHR(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
void(* PFN_vkCmdSetCoverageModulationTableNV)(VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float *pCoverageModulationTable)
Definition: vulkan_core.h:17799
void(* PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions)
Definition: vulkan_core.h:4028
VkResult(* PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t *pCounterCount, VkPerformanceCounterKHR *pCounters, VkPerformanceCounterDescriptionKHR *pCounterDescriptions)
Definition: vulkan_core.h:9546
void(* PFN_vkCmdSetColorBlendEquationEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT *pColorBlendEquations)
Definition: vulkan_core.h:17781
void(* PFN_vkCmdEndRenderPass2)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
Definition: vulkan_core.h:6394
VkResult(* PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI)(VkDevice device, VkRenderPass renderpass, VkExtent2D *pMaxWorkgroupSize)
Definition: vulkan_core.h:16568
void(* PFN_vkCmdSetColorWriteMaskEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags *pColorWriteMasks)
Definition: vulkan_core.h:17782
VkShaderStageFlagBits
Definition: vulkan_core.h:2596
VkResult(* PFN_vkCreateRenderPass2KHR)(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
Definition: vulkan_core.h:9312
VkResult vkGetImageViewOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT *pInfo, void *pData)
void(* PFN_vkGetImageMemoryRequirements2KHR)(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:9744
void(* PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
Definition: vulkan_core.h:4015
void vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
void(* PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
Definition: vulkan_core.h:8871
VkResult(* PFN_vkCreateIndirectCommandsLayoutNV)(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectCommandsLayoutNV *pIndirectCommandsLayout)
Definition: vulkan_core.h:15264
VkResult vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
uint64_t VkSampler
Definition: vulkan_core.h:119
void vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints)
VkResult(* PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties)
Definition: vulkan_core.h:3927
void vkCmdSetDepthClampEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable)
VkResult vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties)
VkResult vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT *pInfo, void *pData)
void vkCmdUpdatePipelineIndirectBufferNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
VkResult vkReleasePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationINTEL configuration)
void vkCmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo)
void vkCmdCopyMemoryIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride)
VkResult(* PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets)
Definition: vulkan_core.h:3990
void(* PFN_vkGetDeviceQueue2)(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue)
Definition: vulkan_core.h:5559
VkResult(* PFN_vkQueueSubmit2KHR)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence)
Definition: vulkan_core.h:10725
VkFlags VkImageAspectFlags
Definition: vulkan_core.h:2202
VkResult vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkLayerProperties *pProperties)
void vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator)
void(* PFN_vkCmdSetSampleMaskEXT)(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask *pSampleMask)
Definition: vulkan_core.h:17776
uint64_t VkRenderPass
Definition: vulkan_core.h:117
void vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties)
void * VkRemoteAddressNV
Definition: vulkan_core.h:16604
void vkDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
VkResult(* PFN_vkWaitSemaphores)(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
Definition: vulkan_core.h:6397
VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainKHR *pTimeDomains)
VkResult(* PFN_vkGetFenceFdKHR)(VkDevice device, const VkFenceGetFdInfoKHR *pGetFdInfo, int *pFd)
Definition: vulkan_core.h:9418
VkResult vkGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice, uint32_t *pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates)
void(* PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements)
Definition: vulkan_core.h:3943
void(* PFN_vkGetShaderModuleCreateInfoIdentifierEXT)(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, VkShaderModuleIdentifierEXT *pIdentifier)
Definition: vulkan_core.h:18064
VkResult(* PFN_vkGetShaderInfoAMD)(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t *pInfoSize, void *pInfo)
Definition: vulkan_core.h:11972
void vkCmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query)
void(* PFN_vkCmdSetLogicOpEXT)(VkCommandBuffer commandBuffer, VkLogicOp logicOp)
Definition: vulkan_core.h:16730
void vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter)
VkResult vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
VkResult vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer)
void vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode)
void(* PFN_vkCmdSetViewportShadingRatePaletteNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV *pShadingRatePalettes)
Definition: vulkan_core.h:13257
void vkCmdSetLineRasterizationModeEXT(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode)
VkResult vkCopyMicromapToMemoryEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT *pInfo)
void vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties)
void vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
void vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT *pMultisampleProperties)
uint64_t VkCommandPool
Definition: vulkan_core.h:123
VkResult vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo, VkFence fence)
VkResult vkGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR *pCapabilities)
void vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties)
#define VK_HEADER_VERSION
Definition: vulkan_core.h:72
void(* PFN_vkResetQueryPool)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
Definition: vulkan_core.h:6395
VkResult vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo)
void(* PFN_vkGetDeviceImageMemoryRequirementsKHR)(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:10957
VkResult vkCreateCudaModuleNV(VkDevice device, const VkCudaModuleCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCudaModuleNV *pModule)
VkResult vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex)
void(* PFN_vkCmdTraceRaysKHR)(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth)
Definition: vulkan_core.h:19219
void vkCmdPushConstants2KHR(VkCommandBuffer commandBuffer, const VkPushConstantsInfoKHR *pPushConstantsInfo)
VkResult(* PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer)
Definition: vulkan_core.h:3963
void(* PFN_vkCmdDrawMeshTasksIndirectCountNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
Definition: vulkan_core.h:13936
uint64_t VkPipelineCache
Definition: vulkan_core.h:114
VkResult(* PFN_vkGetImageViewAddressNVX)(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX *pProperties)
Definition: vulkan_core.h:11871
void(* PFN_vkCmdDrawClusterIndirectHUAWEI)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
Definition: vulkan_core.h:17216
void vkCmdDrawMultiEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT *pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride)
void(* PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
Definition: vulkan_core.h:4020
void vkUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
void(* PFN_vkCmdSetCoverageModulationModeNV)(VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode)
Definition: vulkan_core.h:17797
void(* PFN_vkCmdSetSampleLocationsEXT)(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT *pSampleLocationsInfo)
Definition: vulkan_core.h:12903
void(* PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData)
Definition: vulkan_core.h:4030
void(* PFN_vkGetBufferMemoryRequirements2)(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:5549
void(* PFN_vkCmdSetCullModeEXT)(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode)
Definition: vulkan_core.h:14761
void vkCmdSetAlphaToOneEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable)
void vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
VkResult(* PFN_vkCreateCuModuleNVX)(VkDevice device, const VkCuModuleCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCuModuleNVX *pModule)
Definition: vulkan_core.h:11816
void(* PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3994
void(* PFN_vkCmdSetPrimitiveRestartEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable)
Definition: vulkan_core.h:16731
VkResult(* PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
Definition: vulkan_core.h:3939
VkResult vkReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display)
uint32_t VkSampleMask
Definition: vulkan_core.h:98
VkDeviceAddress vkGetPipelineIndirectDeviceAddressNV(VkDevice device, const VkPipelineIndirectDeviceAddressInfoNV *pInfo)
void vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
void(* PFN_vkCmdEndConditionalRenderingEXT)(VkCommandBuffer commandBuffer)
Definition: vulkan_core.h:12205
VkFlags VkMemoryMapFlags
Definition: vulkan_core.h:2406
VkResult vkCreateVideoSessionKHR(VkDevice device, const VkVideoSessionCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkVideoSessionKHR *pVideoSession)
VkResult(* PFN_vkGetPipelineExecutablePropertiesKHR)(VkDevice device, const VkPipelineInfoKHR *pPipelineInfo, uint32_t *pExecutableCount, VkPipelineExecutablePropertiesKHR *pProperties)
Definition: vulkan_core.h:10393
uint64_t(* PFN_vkGetBufferOpaqueCaptureAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
Definition: vulkan_core.h:10273
void(* PFN_vkSetHdrMetadataEXT)(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR *pSwapchains, const VkHdrMetadataEXT *pMetadata)
Definition: vulkan_core.h:12614
void vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
uint64_t VkEvent
Definition: vulkan_core.h:109
VkResult(* PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT *pInfo, void *pData)
Definition: vulkan_core.h:15879
void vkCmdSetColorBlendAdvancedEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT *pColorBlendAdvanced)
void vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
void vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
void vkCmdSetAlphaToCoverageEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable)
VkResult(* PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT *pSurfaceCapabilities)
Definition: vulkan_core.h:12285
void vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t *pData)
void vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
VkResult(* PFN_vkCmdSetPerformanceOverrideINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL *pOverrideInfo)
Definition: vulkan_core.h:14154
void vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties)
void vkGetDeviceBufferMemoryRequirements(VkDevice device, const VkDeviceBufferMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
void(* PFN_vkCmdBeginRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo)
Definition: vulkan_core.h:9313
void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator)
void(* PFN_vkGetPrivateData)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t *pData)
Definition: vulkan_core.h:7294
uint64_t VkBuffer
Definition: vulkan_core.h:99
VkResult vkLatencySleepNV(VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepInfoNV *pSleepInfo)
VkResult(* PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV)(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesNV *pProperties)
Definition: vulkan_core.h:14518
void(* PFN_vkCmdSetLogicOpEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable)
Definition: vulkan_core.h:17779
VkResult vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
VkFlags VkImageUsageFlags
Definition: vulkan_core.h:2319
void vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT *pBindDescriptorBufferEmbeddedSamplersInfo)
void(* PFN_vkCmdTraceRaysIndirect2KHR)(VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress)
Definition: vulkan_core.h:10929
void vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
VkResult vkCopyImageToMemoryEXT(VkDevice device, const VkCopyImageToMemoryInfoEXT *pCopyImageToMemoryInfo)
PFN_vkVoidFunction vkGetInstanceProcAddr(VkInstance instance, const char *pName)
void(* PFN_vkTrimCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
Definition: vulkan_core.h:5558
VkResult(* PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPlanePropertiesKHR *pProperties)
Definition: vulkan_core.h:7862
void vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator)
VkTessellationDomainOrigin
Definition: vulkan_core.h:4870
void vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource *pSubresource, VkSubresourceLayout *pLayout)
void(* PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets)
Definition: vulkan_core.h:4016
void vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask)
VkResult vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule)
void vkCmdBuildAccelerationStructuresIndirectKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkDeviceAddress *pIndirectDeviceAddresses, const uint32_t *pIndirectStrides, const uint32_t *const *ppMaxPrimitiveCounts)
void vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
VkResult(* PFN_vkEnumeratePhysicalDeviceGroupsKHR)(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties)
Definition: vulkan_core.h:8997
VkResult(* PFN_vkCopyMemoryToMicromapEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT *pInfo)
Definition: vulkan_core.h:17094
VkResult vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void *pData, VkDeviceSize stride, VkQueryResultFlags flags)
void(* PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3925
void(* PFN_vkCmdSetAlphaToOneEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable)
Definition: vulkan_core.h:17778
void vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
void(* PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties)
Definition: vulkan_core.h:3921
VkResult vkResetEvent(VkDevice device, VkEvent event)
VkResult vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
VkTimeDomainKHR
Definition: vulkan_core.h:11292
void(* PFN_vkCmdBeginRenderingKHR)(VkCommandBuffer commandBuffer, const VkRenderingInfo *pRenderingInfo)
Definition: vulkan_core.h:8820
VkResult(* PFN_vkCreateAccelerationStructureKHR)(VkDevice device, const VkAccelerationStructureCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureKHR *pAccelerationStructure)
Definition: vulkan_core.h:19025
VkResult vkGetPipelineExecutableStatisticsKHR(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pStatisticCount, VkPipelineExecutableStatisticKHR *pStatistics)
VkResult(* PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchains)
Definition: vulkan_core.h:7925
void vkCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode)
void vkCmdSetColorBlendEnableEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32 *pColorBlendEnables)
VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes)
VkResult(* PFN_vkBuildMicromapsEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT *pInfos)
Definition: vulkan_core.h:17091
VkResult(* PFN_vkLatencySleepNV)(VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepInfoNV *pSleepInfo)
Definition: vulkan_core.h:18654
uint64_t VkCuModuleNVX
Definition: vulkan_core.h:11781
void(* PFN_vkCmdResolveImage2)(VkCommandBuffer commandBuffer, const VkResolveImageInfo2 *pResolveImageInfo)
Definition: vulkan_core.h:7306
void(* PFN_vkCmdBuildAccelerationStructuresKHR)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR *const *ppBuildRangeInfos)
Definition: vulkan_core.h:19027
void vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator)
void vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator)
void(* PFN_vkCmdCuLaunchKernelNVX)(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX *pLaunchInfo)
Definition: vulkan_core.h:11820
VkResult vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
VkResult vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
void(* PFN_vkCmdCopyBuffer2)(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 *pCopyBufferInfo)
Definition: vulkan_core.h:7301
VkResult(* PFN_vkGetSwapchainStatusKHR)(VkDevice device, VkSwapchainKHR swapchain)
Definition: vulkan_core.h:9350
VkResult(* PFN_vkBindBufferMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
Definition: vulkan_core.h:9824
void vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
VkResult vkGetCudaModuleCacheNV(VkDevice device, VkCudaModuleNV module, size_t *pCacheSize, void *pCacheData)
void vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
VkResult(* PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
Definition: vulkan_core.h:3942
void(* PFN_vkCmdBeginRendering)(VkCommandBuffer commandBuffer, const VkRenderingInfo *pRenderingInfo)
Definition: vulkan_core.h:7307
VkResult vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance)
void vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
void(* PFN_vkCmdSetDescriptorBufferOffsetsEXT)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t *pBufferIndices, const VkDeviceSize *pOffsets)
Definition: vulkan_core.h:15874
void(* PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties)
Definition: vulkan_core.h:3919
VkResult vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
VkResult(* PFN_vkGetCalibratedTimestampsKHR)(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation)
Definition: vulkan_core.h:11310
VkResult(* PFN_vkRegisterDeviceEventEXT)(VkDevice device, const VkDeviceEventInfoEXT *pDeviceEventInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
Definition: vulkan_core.h:12341
void(* PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3988
struct VkPhysicalDevice_T * VkPhysicalDevice
Definition: vulkan_core.h:102
void vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator)
void vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
void(* PFN_vkCmdSetDepthBoundsTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable)
Definition: vulkan_core.h:14770
VkResult(* PFN_vkCreateSamplerYcbcrConversionKHR)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
Definition: vulkan_core.h:9799
void vkCmdSetSampleMaskEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask *pSampleMask)
VkResult(* PFN_vkAcquireProfilingLockKHR)(VkDevice device, const VkAcquireProfilingLockInfoKHR *pInfo)
Definition: vulkan_core.h:9548
void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR *pPerformanceQueryCreateInfo, uint32_t *pNumPasses)
VkResult(* PFN_vkCmdSetPerformanceMarkerINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL *pMarkerInfo)
Definition: vulkan_core.h:14152
void vkCmdDecodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR *pDecodeInfo)
VkResult vkCreateShadersEXT(VkDevice device, uint32_t createInfoCount, const VkShaderCreateInfoEXT *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkShaderEXT *pShaders)
void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties)
void vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t *pPropertyCount, VkSparseImageFormatProperties *pProperties)
void vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D *pScissors)
void(* PFN_vkCmdSetFragmentShadingRateKHR)(VkCommandBuffer commandBuffer, const VkExtent2D *pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
Definition: vulkan_core.h:10184
VkResult vkDeferredOperationJoinKHR(VkDevice device, VkDeferredOperationKHR operation)
void(* PFN_vkGetRenderingAreaGranularityKHR)(VkDevice device, const VkRenderingAreaInfoKHR *pRenderingAreaInfo, VkExtent2D *pGranularity)
Definition: vulkan_core.h:11114
VkResult(* PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkEvent *pEvent)
Definition: vulkan_core.h:3955
void vkGetImageSubresourceLayout2KHR(VkDevice device, VkImage image, const VkImageSubresource2KHR *pSubresource, VkSubresourceLayout2KHR *pLayout)
void(* PFN_vkCmdUpdatePipelineIndirectBufferNV)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
Definition: vulkan_core.h:17596
void(* PFN_vkCmdSetFrontFace)(VkCommandBuffer commandBuffer, VkFrontFace frontFace)
Definition: vulkan_core.h:7310
VkResult(* PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties)
Definition: vulkan_core.h:12037
void(* PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
Definition: vulkan_core.h:4032
void(* PFN_vkCmdResolveImage2KHR)(VkCommandBuffer commandBuffer, const VkResolveImageInfo2 *pResolveImageInfo)
Definition: vulkan_core.h:10860
VkResult vkWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
void(* PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3986
void vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize)
void vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable)
void(* PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents)
Definition: vulkan_core.h:4047
void(* PFN_vkSubmitDebugUtilsMessageEXT)(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData)
Definition: vulkan_core.h:12741
VkFlags VkDependencyFlags
Definition: vulkan_core.h:2717
void vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
void vkCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo)
VkResult vkCreateCuModuleNVX(VkDevice device, const VkCuModuleCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCuModuleNVX *pModule)
void vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator)
void(* PFN_vkGetDescriptorSetLayoutBindingOffsetEXT)(VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize *pOffset)
Definition: vulkan_core.h:15871
void(* PFN_vkCmdSetTessellationDomainOriginEXT)(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin)
Definition: vulkan_core.h:17772
VkCoarseSampleOrderTypeNV
Definition: vulkan_core.h:13200
void(* PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3996
void vkCmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport *pViewports)
void vkCmdCopyAccelerationStructureToMemoryKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo)
void(* PFN_vkCmdSetRasterizerDiscardEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable)
Definition: vulkan_core.h:16728
VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
void(* PFN_vkResetQueryPoolEXT)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
Definition: vulkan_core.h:14728
VkResult(* PFN_vkBindBufferMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
Definition: vulkan_core.h:5542
void(* PFN_vkCmdSetFrontFaceEXT)(VkCommandBuffer commandBuffer, VkFrontFace frontFace)
Definition: vulkan_core.h:14762
VkShaderGroupShaderKHR
Definition: vulkan_core.h:19142
void(* PFN_vkCmdControlVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR *pCodingControlInfo)
Definition: vulkan_core.h:8164
void vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks *pAllocator)
VkResult vkGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t *pPropertyCount, VkDisplayModePropertiesKHR *pProperties)
void(* PFN_vkCmdBindVertexBuffers2EXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes, const VkDeviceSize *pStrides)
Definition: vulkan_core.h:14766
uint64_t VkFramebuffer
Definition: vulkan_core.h:122
void vkCmdBeginVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR *pBeginInfo)
VkResult vkGetDeferredOperationResultKHR(VkDevice device, VkDeferredOperationKHR operation)
void(* PFN_vkGetPhysicalDeviceFormatProperties2KHR)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
Definition: vulkan_core.h:8869
void vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData)
void(* PFN_vkCmdSetDepthWriteEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable)
Definition: vulkan_core.h:14768
void(* PFN_vkCmdBeginRenderPass2)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo)
Definition: vulkan_core.h:6392
PFN_vkVoidFunction(* PFN_vkGetDeviceProcAddr)(VkDevice device, const char *pName)
Definition: vulkan_core.h:3923
void(* PFN_vkCmdBuildAccelerationStructuresIndirectKHR)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkDeviceAddress *pIndirectDeviceAddresses, const uint32_t *pIndirectStrides, const uint32_t *const *ppMaxPrimitiveCounts)
Definition: vulkan_core.h:19028
void vkCmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2 *pBlitImageInfo)
VkResult vkGetSamplerOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT *pInfo, void *pData)
void(* PFN_vkDestroyIndirectCommandsLayoutNV)(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:15265
VkResult(* PFN_vkCreateDebugUtilsMessengerEXT)(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugUtilsMessengerEXT *pMessenger)
Definition: vulkan_core.h:12739
VkResult vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
void vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks *pAllocator)
VkResult vkRegisterDeviceEventEXT(VkDevice device, const VkDeviceEventInfoEXT *pDeviceEventInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
void vkGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
void(* PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4])
Definition: vulkan_core.h:4011
VkResult(* PFN_vkResetEvent)(VkDevice device, VkEvent event)
Definition: vulkan_core.h:3959
void(* PFN_vkCmdPushDescriptorSetWithTemplateKHR)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void *pData)
Definition: vulkan_core.h:9180
VkResult(* PFN_vkGetDeviceGroupSurfacePresentModesKHR)(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR *pModes)
Definition: vulkan_core.h:7731
uint64_t VkDeviceSize
Definition: vulkan_core.h:96
VkResult(* PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR *pQualityLevelInfo, VkVideoEncodeQualityLevelPropertiesKHR *pQualityLevelProperties)
Definition: vulkan_core.h:10652
void(* PFN_vkCmdSetDepthCompareOp)(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp)
Definition: vulkan_core.h:7317
void vkQueueEndDebugUtilsLabelEXT(VkQueue queue)
void vkDestroyVideoSessionParametersKHR(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks *pAllocator)
void vkCmdPushDescriptorSet2KHR(VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfoKHR *pPushDescriptorSetInfo)
void(* PFN_vkGetAccelerationStructureBuildSizesKHR)(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR *pBuildInfo, const uint32_t *pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR *pSizeInfo)
Definition: vulkan_core.h:19040
void vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp)
void vkCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, const VkExtent2D *pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
VkResult vkCreatePrivateDataSlot(VkDevice device, const VkPrivateDataSlotCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPrivateDataSlot *pPrivateDataSlot)
VkResult vkCopyAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR *pInfo)
VkDeviceAddress vkGetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
void(* PFN_vkCmdBeginConditionalRenderingEXT)(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin)
Definition: vulkan_core.h:12204
VkResult vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool)
void vkQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
void(* PFN_vkGetImageSparseMemoryRequirements2)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
Definition: vulkan_core.h:5550
void(* PFN_vkCmdSetEvent2)(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo *pDependencyInfo)
Definition: vulkan_core.h:7295
VkResult(* PFN_vkGetPhysicalDeviceImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
Definition: vulkan_core.h:5554
VkResult vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets)
VkResult vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation)
void vkGetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t *pData)
void vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData)
uint64_t VkBufferView
Definition: vulkan_core.h:111
VkResult(* PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferView *pView)
Definition: vulkan_core.h:3965
VkResult(* PFN_vkGetPhysicalDeviceToolProperties)(VkPhysicalDevice physicalDevice, uint32_t *pToolCount, VkPhysicalDeviceToolProperties *pToolProperties)
Definition: vulkan_core.h:7290
VkResult(* PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR *pCapabilities)
Definition: vulkan_core.h:7866
VkResult(* PFN_vkGetRefreshCycleDurationGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE *pDisplayTimingProperties)
Definition: vulkan_core.h:12400
void(* PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3954
void vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets)
void(* PFN_vkCmdSetDepthBias2EXT)(VkCommandBuffer commandBuffer, const VkDepthBiasInfoEXT *pDepthBiasInfo)
Definition: vulkan_core.h:15389
void(* PFN_vkCmdWaitEvents2KHR)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, const VkDependencyInfo *pDependencyInfos)
Definition: vulkan_core.h:10722
void vkCmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfo *pRenderingInfo)
uint64_t VkCudaModuleNV
Definition: vulkan_core.h:15632
VkResult(* PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, VkSurfaceCapabilities2KHR *pSurfaceCapabilities)
Definition: vulkan_core.h:9617
VkResult(* PFN_vkSetPrivateData)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data)
Definition: vulkan_core.h:7293
struct VkQueue_T * VkQueue
Definition: vulkan_core.h:104
void vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
VkFlags VkStencilFaceFlags
Definition: vulkan_core.h:2789
void(* PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions)
Definition: vulkan_core.h:4025
void vkCmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes, const VkDeviceSize *pStrides)
void(* PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties)
Definition: vulkan_core.h:9032
void(* PFN_vkCmdBeginVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR *pBeginInfo)
Definition: vulkan_core.h:8162
VkResult vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT *pProperties)
uint64_t VkDisplayKHR
Definition: vulkan_core.h:7789
void(* PFN_vkCmdPushDescriptorSetKHR)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites)
Definition: vulkan_core.h:9179
void vkCmdSetExclusiveScissorEnableNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkBool32 *pExclusiveScissorEnables)
VkResult(* PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes)
Definition: vulkan_core.h:7593
void(* PFN_vkCmdBeginQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
Definition: vulkan_core.h:11728
void vkResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
VkFlags VkExternalMemoryHandleTypeFlagsNV
Definition: vulkan_core.h:12021
void vkCmdSetDiscardRectangleModeEXT(VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode)
void vkCmdSetDepthClipNegativeOneToOneEXT(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne)
void(* PFN_vkCmdSetCoverageToColorLocationNV)(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation)
Definition: vulkan_core.h:17796
VkResult vkCreateRayTracingPipelinesKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
VkResult(* PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t *pPropertyCount, VkDisplayModePropertiesKHR *pProperties)
Definition: vulkan_core.h:7864
VkResult vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 *pSupported)
void vkCmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable)
void vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
VkResult vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSampler *pSampler)
VkResult(* PFN_vkEnumerateInstanceLayerProperties)(uint32_t *pPropertyCount, VkLayerProperties *pProperties)
Definition: vulkan_core.h:3928
void(* PFN_vkCmdSetScissorWithCountEXT)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D *pScissors)
Definition: vulkan_core.h:14765
void vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions)
void vkCmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo)
void vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
VkCoverageReductionModeNV
Definition: vulkan_core.h:14533
VkImageTiling
Definition: vulkan_core.h:1714
void(* PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer)
Definition: vulkan_core.h:4048
uint64_t VkDisplayModeKHR
Definition: vulkan_core.h:7790
VkResult vkCreateMicromapEXT(VkDevice device, const VkMicromapCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkMicromapEXT *pMicromap)
void vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4])
void(* PFN_vkCmdDrawMeshTasksEXT)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
Definition: vulkan_core.h:19339
VkResult vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage)
VkResult(* PFN_vkDeviceWaitIdle)(VkDevice device)
Definition: vulkan_core.h:3933
void vkGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
void vkCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
void(* PFN_vkCmdDecodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR *pDecodeInfo)
Definition: vulkan_core.h:8277
VkPipelineBindPoint
Definition: vulkan_core.h:2111
void(* PFN_vkCmdSetDepthClipNegativeOneToOneEXT)(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne)
Definition: vulkan_core.h:17792
VkFlags VkCommandPoolTrimFlags
Definition: vulkan_core.h:4952
VkResult vkDeviceWaitIdle(VkDevice device)
void(* PFN_vkCmdBindVertexBuffers2)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes, const VkDeviceSize *pStrides)
Definition: vulkan_core.h:7314
VkResult(* PFN_vkCreateAccelerationStructureNV)(VkDevice device, const VkAccelerationStructureCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureNV *pAccelerationStructure)
Definition: vulkan_core.h:13544
VkResult(* PFN_vkSignalSemaphore)(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
Definition: vulkan_core.h:6398
void vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue)
VkAccelerationStructureCompatibilityKHR
Definition: vulkan_core.h:16952
void(* PFN_vkCmdBindDescriptorBuffersEXT)(VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT *pBindingInfos)
Definition: vulkan_core.h:15873
void vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable)
void(* PFN_vkUninitializePerformanceApiINTEL)(VkDevice device)
Definition: vulkan_core.h:14151
uint32_t vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation)
void vkCmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
VkResult(* PFN_vkCreateHeadlessSurfaceEXT)(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
Definition: vulkan_core.h:14640
void vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2 *pBlitImageInfo)
void(* PFN_vkCmdCopyAccelerationStructureKHR)(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR *pInfo)
Definition: vulkan_core.h:19034
VkResult vkSignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
void vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
void vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin)
VkResult vkCopyMemoryToImageEXT(VkDevice device, const VkCopyMemoryToImageInfoEXT *pCopyMemoryToImageInfo)
VkResult vkEnumerateInstanceVersion(uint32_t *pApiVersion)
VkResult vkCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL *pOverrideInfo)
void vkCmdSetDiscardRectangleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable)
VkResult vkCreatePrivateDataSlotEXT(VkDevice device, const VkPrivateDataSlotCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPrivateDataSlot *pPrivateDataSlot)
VkResult(* PFN_vkGetValidationCacheDataEXT)(VkDevice device, VkValidationCacheEXT validationCache, size_t *pDataSize, void *pData)
Definition: vulkan_core.h:13125
void vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
VkResult(* PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain)
Definition: vulkan_core.h:7725
void vkCmdEndRenderingKHR(VkCommandBuffer commandBuffer)
void(* PFN_vkCmdDrawIndirectByteCountEXT)(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
Definition: vulkan_core.h:11730
VkResult(* PFN_vkGetPhysicalDevicePresentRectanglesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pRectCount, VkRect2D *pRects)
Definition: vulkan_core.h:7732
void(* PFN_vkDestroyOpticalFlowSessionNV)(VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:18214
void(* PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
Definition: vulkan_core.h:4044
VkResult(* PFN_vkCreateRayTracingPipelinesKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
Definition: vulkan_core.h:19220
VkResult(* PFN_vkDeferredOperationJoinKHR)(VkDevice device, VkDeferredOperationKHR operation)
Definition: vulkan_core.h:10300
void vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
VkResult vkCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDisplayModeKHR *pMode)
VkShaderInfoTypeAMD
Definition: vulkan_core.h:11948
void vkCmdBindDescriptorBuffersEXT(VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT *pBindingInfos)
VkResult(* PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets)
Definition: vulkan_core.h:3991
void(* PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkSubpassContents contents)
Definition: vulkan_core.h:4046
void(* PFN_vkCmdCudaLaunchKernelNV)(VkCommandBuffer commandBuffer, const VkCudaLaunchInfoNV *pLaunchInfo)
Definition: vulkan_core.h:15685
void vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char *pLayerPrefix, const char *pMessage)
VkDeviceAddress vkGetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
void(* PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3975
VkStencilOp
Definition: vulkan_core.h:2002
void vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask)
VkDeviceSize(* PFN_vkGetRayTracingShaderGroupStackSizeKHR)(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader)
Definition: vulkan_core.h:19223
void vkDestroyIndirectCommandsLayoutNV(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks *pAllocator)
void(* PFN_vkCmdSetCoverageReductionModeNV)(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode)
Definition: vulkan_core.h:17802
VkResult(* PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
Definition: vulkan_core.h:3948
void(* PFN_vkGetMicromapBuildSizesEXT)(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT *pBuildInfo, VkMicromapBuildSizesInfoEXT *pSizeInfo)
Definition: vulkan_core.h:17101
VkResult vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pCallback)
void(* PFN_vkCmdPipelineBarrier2)(VkCommandBuffer commandBuffer, const VkDependencyInfo *pDependencyInfo)
Definition: vulkan_core.h:7298
void vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue)
void vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern)
VkResult vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache)
void(* PFN_vkCmdBeginTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
Definition: vulkan_core.h:11726
void(* PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
Definition: vulkan_core.h:4021
void(* PFN_vkDestroyPrivateDataSlot)(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:7292
void(* PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
Definition: vulkan_core.h:4036
void(* PFN_vkGetDescriptorSetLayoutSupport)(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
Definition: vulkan_core.h:5568
VkResult vkCreateIndirectCommandsLayoutNV(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectCommandsLayoutNV *pIndirectCommandsLayout)
VkResult(* PFN_vkGetPerformanceParameterINTEL)(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL *pValue)
Definition: vulkan_core.h:14158
void(* PFN_vkSetDeviceMemoryPriorityEXT)(VkDevice device, VkDeviceMemory memory, float priority)
Definition: vulkan_core.h:17262
VkResult(* PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
Definition: vulkan_core.h:3938
void vkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
void(* PFN_vkCmdSetExclusiveScissorNV)(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D *pExclusiveScissors)
Definition: vulkan_core.h:14000
VkResult(* PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void *pData, VkDeviceSize stride, VkQueryResultFlags flags)
Definition: vulkan_core.h:3962
void(* PFN_vkCmdSetAlphaToCoverageEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable)
Definition: vulkan_core.h:17777
VkResult vkCreateValidationCacheEXT(VkDevice device, const VkValidationCacheCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkValidationCacheEXT *pValidationCache)
void vkCmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 *pCopyBufferInfo)
void(* PFN_vkCmdSetColorBlendEnableEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32 *pColorBlendEnables)
Definition: vulkan_core.h:17780
VkOpticalFlowSessionBindingPointNV
Definition: vulkan_core.h:18099
void vkCmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable)
VkResult(* PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR)(VkPhysicalDevice physicalDevice, uint32_t *pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates)
Definition: vulkan_core.h:10183
VkResult(* PFN_vkGetCalibratedTimestampsEXT)(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation)
Definition: vulkan_core.h:13788
void(* PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
Definition: vulkan_core.h:4040
VkResult(* PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
Definition: vulkan_core.h:8870
void vkDestroyAccelerationStructureKHR(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks *pAllocator)
VkResult(* PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT *pInfo, void *pData)
Definition: vulkan_core.h:15880
VkResult vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches)
void(* PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues)
Definition: vulkan_core.h:4045
void(* PFN_vkCmdSetDepthBiasEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable)
Definition: vulkan_core.h:16729
VkResult(* PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities)
Definition: vulkan_core.h:7591
void(* PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:11528
VkResult vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data)
VkResult vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void **ppData)
VkResult(* PFN_vkCopyMicromapToMemoryEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT *pInfo)
Definition: vulkan_core.h:17093
void(* PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT)(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT *pMultisampleProperties)
Definition: vulkan_core.h:12904
void vkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
VkResult vkGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayProperties2KHR *pProperties)
VkResult vkGetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice, uint32_t *pToolCount, VkPhysicalDeviceToolProperties *pToolProperties)
void vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
void vkCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable)
void vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D *pDiscardRectangles)
void(* PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D *pDiscardRectangles)
Definition: vulkan_core.h:12509
void vkCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
VkResult vkCopyAccelerationStructureToMemoryKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo)
VkResult(* PFN_vkCmdSetPerformanceStreamMarkerINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL *pMarkerInfo)
Definition: vulkan_core.h:14153
void(* PFN_vkCmdEndTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
Definition: vulkan_core.h:11727
VkResult vkCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
void vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties *pFormatProperties)
VkResult vkGetPhysicalDeviceExternalImageFormatPropertiesNV(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties)
void(* PFN_vkCmdSetDepthClampEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable)
Definition: vulkan_core.h:17773
void(* PFN_vkCmdCopyImage2)(VkCommandBuffer commandBuffer, const VkCopyImageInfo2 *pCopyImageInfo)
Definition: vulkan_core.h:7302
void vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
VkResult(* PFN_vkCreatePrivateDataSlot)(VkDevice device, const VkPrivateDataSlotCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPrivateDataSlot *pPrivateDataSlot)
Definition: vulkan_core.h:7291
void vkCmdCudaLaunchKernelNV(VkCommandBuffer commandBuffer, const VkCudaLaunchInfoNV *pLaunchInfo)
VkResult vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL *pValue)
void(* PFN_vkCmdSetCullMode)(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode)
Definition: vulkan_core.h:7309
void vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
VkResult vkGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore, uint64_t *pValue)
VkResult(* PFN_vkGetMemoryFdPropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR *pMemoryFdProperties)
Definition: vulkan_core.h:9080
VkResult(* PFN_vkGetPastPresentationTimingGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pPresentationTimingCount, VkPastPresentationTimingGOOGLE *pPresentationTimings)
Definition: vulkan_core.h:12401
VkResult(* PFN_vkImportFenceFdKHR)(VkDevice device, const VkImportFenceFdInfoKHR *pImportFenceFdInfo)
Definition: vulkan_core.h:9417
void vkCmdSetDescriptorBufferOffsetsEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t *pBufferIndices, const VkDeviceSize *pOffsets)
struct VkInstance_T * VkInstance
Definition: vulkan_core.h:101
void(* PFN_vkCmdNextSubpass2)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo)
Definition: vulkan_core.h:6393
void(* PFN_vkCmdCopyImage2KHR)(VkCommandBuffer commandBuffer, const VkCopyImageInfo2 *pCopyImageInfo)
Definition: vulkan_core.h:10856
VkResult vkGetBufferOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT *pInfo, void *pData)
struct VkDevice_T * VkDevice
Definition: vulkan_core.h:103
void(* PFN_vkGetPhysicalDeviceExternalSemaphoreProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties)
Definition: vulkan_core.h:5567
VkResult vkCopyImageToImageEXT(VkDevice device, const VkCopyImageToImageInfoEXT *pCopyImageToImageInfo)
VkResult vkGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t *pDisplayCount, VkDisplayKHR *pDisplays)
void(* PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
Definition: vulkan_core.h:8937
uint64_t VkDeferredOperationKHR
Definition: vulkan_core.h:10293
VkSurfaceCounterFlagBitsEXT
Definition: vulkan_core.h:12263
void vkCmdSetCoverageModulationTableEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable)
VkResult vkRegisterDisplayEventEXT(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT *pDisplayEventInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
void(* PFN_vkCmdSetDiscardRectangleModeEXT)(VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode)
Definition: vulkan_core.h:12511
VkResult vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
void(* PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3961
VkDebugReportObjectTypeEXT
Definition: vulkan_core.h:11451
VkResult vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory)
VkResult vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities)
VkResult(* PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout)
Definition: vulkan_core.h:3952
VkResult vkCreateDeferredOperationKHR(VkDevice device, const VkAllocationCallbacks *pAllocator, VkDeferredOperationKHR *pDeferredOperation)
VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesKHR *pProperties)
uint64_t VkOpticalFlowSessionNV
Definition: vulkan_core.h:18087
VkResult(* PFN_vkGetSwapchainCounterEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t *pCounterValue)
Definition: vulkan_core.h:12343
void vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32 *pColorWriteEnables)
void vkCmdSetRepresentativeFragmentTestEnableNV(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable)
void vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator)
void vkCmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT *pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t *pVertexOffset)
void(* PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3973
VkResult vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties)
VkResult vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
VkFlags VkPeerMemoryFeatureFlags
Definition: vulkan_core.h:4940
void(* PFN_vkCmdDispatchBaseKHR)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
Definition: vulkan_core.h:8939
void(* PFN_vkCmdSetCoarseSampleOrderNV)(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV *pCustomSampleOrders)
Definition: vulkan_core.h:13258
void vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
VkResult vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t *pInfoSize, void *pInfo)
void vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable)
void(* PFN_vkCmdPreprocessGeneratedCommandsNV)(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
Definition: vulkan_core.h:15261
void(* PFN_vkCmdSetFragmentShadingRateEnumNV)(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
Definition: vulkan_core.h:16041
void(* PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties)
Definition: vulkan_core.h:9375
uint64_t VkFence
Definition: vulkan_core.h:107
VkResult vkCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
void(* PFN_vkCmdSetColorWriteEnableEXT)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32 *pColorWriteEnables)
Definition: vulkan_core.h:16773
void(* PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3982
void(* PFN_vkCmdSetPrimitiveRestartEnable)(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable)
Definition: vulkan_core.h:7323
void(* PFN_vkDestroyDescriptorUpdateTemplateKHR)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:9257
void(* PFN_vkCmdSetCoverageToColorEnableNV)(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable)
Definition: vulkan_core.h:17795
void(* PFN_vkDestroyAccelerationStructureKHR)(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:19026
VkResult vkGetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
void vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements)
void vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
void(* PFN_vkCmdBuildMicromapsEXT)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT *pInfos)
Definition: vulkan_core.h:17090
VkDeviceAddress vkGetBufferDeviceAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
uint64_t VkDescriptorSet
Definition: vulkan_core.h:120
VkResult(* PFN_vkGetDynamicRenderingTilePropertiesQCOM)(VkDevice device, const VkRenderingInfo *pRenderingInfo, VkTilePropertiesQCOM *pProperties)
Definition: vulkan_core.h:18380
void(* PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3935
VkResult(* PFN_vkGetEventStatus)(VkDevice device, VkEvent event)
Definition: vulkan_core.h:3957
void vkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer, const VkRenderingInfo *pRenderingInfo)
void vkReleaseProfilingLockKHR(VkDevice device)
VkResult(* PFN_vkGetRayTracingShaderGroupHandlesNV)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
Definition: vulkan_core.h:13553
VkResult vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
void vkGetDescriptorSetHostMappingVALVE(VkDevice device, VkDescriptorSet descriptorSet, void **ppData)
void vkSetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory, float priority)
VkSampleCountFlagBits
Definition: vulkan_core.h:2282
void(* PFN_vkCmdPushDescriptorSetWithTemplate2KHR)(VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfoKHR *pPushDescriptorSetWithTemplateInfo)
Definition: vulkan_core.h:11414
VkExternalMemoryHandleTypeFlagBits
Definition: vulkan_core.h:4955
void vkCmdCopyMemoryToImageIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers *pImageSubresources)
VkResult(* PFN_vkWaitSemaphoresKHR)(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
Definition: vulkan_core.h:10083
VkResult(* PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR *pVideoFormatInfo, uint32_t *pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR *pVideoFormatProperties)
Definition: vulkan_core.h:8154
VkQueryType
Definition: vulkan_core.h:1737
void vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void *pData)
void(* PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports)
Definition: vulkan_core.h:4007
void vkCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV *pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset)
void(* PFN_vkCmdSetDiscardRectangleEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable)
Definition: vulkan_core.h:12510
void(* PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3980
void vkUnmapMemory(VkDevice device, VkDeviceMemory memory)
void vkCmdBindDescriptorBufferEmbeddedSamplersEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set)
void vkCmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2 *pCopyImageInfo)
VkResult vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferView *pView)
VkResult(* PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkLayerProperties *pProperties)
Definition: vulkan_core.h:3929
void(* PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
Definition: vulkan_core.h:11889
void vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable)
VkResult(* PFN_vkGetMemoryHostPointerPropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer, VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties)
Definition: vulkan_core.h:13735
void(* PFN_vkCmdSetRasterizationSamplesEXT)(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples)
Definition: vulkan_core.h:17775
VkResult(* PFN_vkCopyImageToMemoryEXT)(VkDevice device, const VkCopyImageToMemoryInfoEXT *pCopyImageToMemoryInfo)
Definition: vulkan_core.h:14944
void(* PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
Definition: vulkan_core.h:11636
void(* PFN_vkCmdDrawMeshTasksIndirectCountEXT)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
Definition: vulkan_core.h:19341
VkResult vkQueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence)
void vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask)
VkResult(* PFN_vkCreateCudaModuleNV)(VkDevice device, const VkCudaModuleCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCudaModuleNV *pModule)
Definition: vulkan_core.h:15680
VkResult vkBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV *pBindInfos)
VkFlags VkDebugUtilsMessageTypeFlagsEXT
Definition: vulkan_core.h:12672
VkResult(* PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImageView *pView)
Definition: vulkan_core.h:3970
void(* PFN_vkDestroyMicromapEXT)(VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:17089
VkFragmentShadingRateCombinerOpKHR
Definition: vulkan_core.h:10124
void vkCmdSetViewportWScalingEnableNV(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable)
void vkCmdDrawMeshTasksIndirectEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
void(* PFN_vkGetPhysicalDeviceProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties)
Definition: vulkan_core.h:8868
void(* PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D *pGranularity)
Definition: vulkan_core.h:3997
VkResult vkCreateCudaFunctionNV(VkDevice device, const VkCudaFunctionCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCudaFunctionNV *pFunction)
void(* PFN_vkVoidFunction)(void)
Definition: vulkan_core.h:2925
VkResult vkCopyMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT *pInfo)
VkResult(* PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo, VkFence fence)
Definition: vulkan_core.h:3947
void vkCmdSetDescriptorBufferOffsets2EXT(VkCommandBuffer commandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT *pSetDescriptorBufferOffsetsInfo)
void vkGetDeviceAccelerationStructureCompatibilityKHR(VkDevice device, const VkAccelerationStructureVersionInfoKHR *pVersionInfo, VkAccelerationStructureCompatibilityKHR *pCompatibility)
void(* PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
Definition: vulkan_core.h:4012
VkDeviceSize vkGetRayTracingShaderGroupStackSizeKHR(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader)
VkResult vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice)
PFN_vkVoidFunction(* PFN_vkGetInstanceProcAddr)(VkInstance instance, const char *pName)
Definition: vulkan_core.h:3922
void(* PFN_vkCmdDrawMeshTasksIndirectNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
Definition: vulkan_core.h:13935
VkResult(* PFN_vkCopyMemoryToImageEXT)(VkDevice device, const VkCopyMemoryToImageInfoEXT *pCopyMemoryToImageInfo)
Definition: vulkan_core.h:14943
uint64_t VkDescriptorPool
Definition: vulkan_core.h:121
VkResult(* PFN_vkCreateDebugReportCallbackEXT)(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pCallback)
Definition: vulkan_core.h:11527
void vkCmdDecompressMemoryIndirectCountNV(VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride)
void(* PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers)
Definition: vulkan_core.h:4002
void vkCmdSetDepthClipEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable)
VkResult vkQueueWaitIdle(VkQueue queue)
VkConservativeRasterizationModeEXT
Definition: vulkan_core.h:12535
VkDeviceAddress(* PFN_vkGetBufferDeviceAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
Definition: vulkan_core.h:10272
void vkCmdSetCoverageReductionModeNV(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode)
VkResult(* PFN_vkCreateMicromapEXT)(VkDevice device, const VkMicromapCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkMicromapEXT *pMicromap)
Definition: vulkan_core.h:17088
void vkCmdBindIndexBuffer2KHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType)
VkResult(* PFN_vkCreateShadersEXT)(VkDevice device, uint32_t createInfoCount, const VkShaderCreateInfoEXT *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkShaderEXT *pShaders)
Definition: vulkan_core.h:18329
uint64_t(* PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
Definition: vulkan_core.h:10274
void(* PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3971
void(* PFN_vkCmdSetDepthClipEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable)
Definition: vulkan_core.h:17786
uint64_t VkAccelerationStructureNV
Definition: vulkan_core.h:13282
VkResult(* PFN_vkGetDeferredOperationResultKHR)(VkDevice device, VkDeferredOperationKHR operation)
Definition: vulkan_core.h:10299
void(* PFN_vkCmdWriteBufferMarker2AMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
Definition: vulkan_core.h:10726
void vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
void(* PFN_vkCmdInsertDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
Definition: vulkan_core.h:12738
VkFlags VkQueryControlFlags
Definition: vulkan_core.h:2774
VkResult vkInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL *pInitializeInfo)
void(* PFN_vkCmdSetEvent2KHR)(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo *pDependencyInfo)
Definition: vulkan_core.h:10720
uint64_t VkSwapchainKHR
Definition: vulkan_core.h:7628
void(* PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3914
VkResult vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData)
void(* PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures)
Definition: vulkan_core.h:3916
void(* PFN_vkGetDeviceAccelerationStructureCompatibilityKHR)(VkDevice device, const VkAccelerationStructureVersionInfoKHR *pVersionInfo, VkAccelerationStructureCompatibilityKHR *pCompatibility)
Definition: vulkan_core.h:19039
void(* PFN_vkGetImageSubresourceLayout2EXT)(VkDevice device, VkImage image, const VkImageSubresource2KHR *pSubresource, VkSubresourceLayout2KHR *pLayout)
Definition: vulkan_core.h:14947
VkResult(* PFN_vkEnumeratePhysicalDeviceGroups)(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties)
Definition: vulkan_core.h:5547
void(* PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
Definition: vulkan_core.h:4019
void(* PFN_vkCmdTraceRaysIndirectKHR)(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress)
Definition: vulkan_core.h:19222
void vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks *pAllocator)
void(* PFN_vkCmdCopyImageToBuffer2)(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo)
Definition: vulkan_core.h:7304
void vkCmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo *pDependencyInfo)
VkResult vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader)
VkResult vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer, VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties)
void vkCmdEndRendering(VkCommandBuffer commandBuffer)
void vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology)
VkResult(* PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
Definition: vulkan_core.h:4000
void vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV *pViewportWScalings)
VkCompareOp
Definition: vulkan_core.h:1864
VkResult vkBindVideoSessionMemoryKHR(VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR *pBindSessionMemoryInfos)
void vkCmdPushDescriptorSetWithTemplate2KHR(VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfoKHR *pPushDescriptorSetWithTemplateInfo)
VkDeviceAddress vkGetAccelerationStructureDeviceAddressKHR(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR *pInfo)
VkResult(* PFN_vkGetFramebufferTilePropertiesQCOM)(VkDevice device, VkFramebuffer framebuffer, uint32_t *pPropertiesCount, VkTilePropertiesQCOM *pProperties)
Definition: vulkan_core.h:18379
void vkGetImageSparseMemoryRequirements2KHR(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
void(* PFN_vkCmdCopyMemoryToMicromapEXT)(VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT *pInfo)
Definition: vulkan_core.h:17098
VkResult vkSetLatencySleepModeNV(VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepModeInfoNV *pSleepModeInfo)
void(* PFN_vkCmdSetSampleLocationsEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable)
Definition: vulkan_core.h:17787
VkResult vkCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchains)
uint64_t VkPipelineLayout
Definition: vulkan_core.h:115
void vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues)
void(* PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer commandBuffer)
Definition: vulkan_core.h:11635
void vkSetLocalDimmingAMD(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable)
VkLogicOp
Definition: vulkan_core.h:2014
VkResult vkCreateHeadlessSurfaceEXT(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
void vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents)
void vkCmdDecompressMemoryNV(VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV *pDecompressMemoryRegions)
uint64_t VkShaderEXT
Definition: vulkan_core.h:18276
void(* PFN_vkCmdTraceRaysNV)(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth)
Definition: vulkan_core.h:13550
void vkCmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable)
void(* PFN_vkCmdBlitImage2KHR)(VkCommandBuffer commandBuffer, const VkBlitImageInfo2 *pBlitImageInfo)
Definition: vulkan_core.h:10859
VkResult vkQueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration)
VkResult vkEnumerateInstanceLayerProperties(uint32_t *pPropertyCount, VkLayerProperties *pProperties)
VkResult vkDisplayPowerControlEXT(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT *pDisplayPowerInfo)
void(* PFN_vkCmdBlitImage2)(VkCommandBuffer commandBuffer, const VkBlitImageInfo2 *pBlitImageInfo)
Definition: vulkan_core.h:7305
void vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator)
VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT *pSurfaceCapabilities)
void(* PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
Definition: vulkan_core.h:4031
void vkDestroyCudaModuleNV(VkDevice device, VkCudaModuleNV module, const VkAllocationCallbacks *pAllocator)
void vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D *pGranularity)
void(* PFN_vkGetDescriptorEXT)(VkDevice device, const VkDescriptorGetInfoEXT *pDescriptorInfo, size_t dataSize, void *pDescriptor)
Definition: vulkan_core.h:15872
VkResult(* PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPropertiesKHR *pProperties)
Definition: vulkan_core.h:7861
void vkCmdSetViewportSwizzleNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV *pViewportSwizzles)
VkResult vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT *pNameInfo)
VkResult vkGetDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR *display)
VkResult(* PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence)
Definition: vulkan_core.h:3931
VkResult(* PFN_vkCreateDescriptorUpdateTemplate)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
Definition: vulkan_core.h:5562
VkResult vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
VkFlags VkCommandPoolResetFlags
Definition: vulkan_core.h:2760
void vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator)
VkResult vkAcquireDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display)
void vkDestroyOpticalFlowSessionNV(VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks *pAllocator)
void(* PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3999
void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks *pAllocator)
void vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports)
VkResult vkGetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain)
VkResult vkBuildMicromapsEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT *pInfos)
VkResult vkGetFenceStatus(VkDevice device, VkFence fence)
void(* PFN_vkGetGeneratedCommandsMemoryRequirementsNV)(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:15260
VkPerformanceParameterTypeINTEL
Definition: vulkan_core.h:14083
void(* PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
Definition: vulkan_core.h:4042
VkCoverageModulationModeNV
Definition: vulkan_core.h:12976
void vkCmdOpticalFlowExecuteNV(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV *pExecuteInfo)
VkResult(* PFN_vkReleaseDisplayEXT)(VkPhysicalDevice physicalDevice, VkDisplayKHR display)
Definition: vulkan_core.h:12249
VkResult vkUpdateVideoSessionParametersKHR(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR *pUpdateInfo)
void vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
VkResult(* PFN_vkCreateOpticalFlowSessionNV)(VkDevice device, const VkOpticalFlowSessionCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkOpticalFlowSessionNV *pSession)
Definition: vulkan_core.h:18213
void(* PFN_vkCmdBindPipelineShaderGroupNV)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex)
Definition: vulkan_core.h:15263
void vkGetDeviceBufferMemoryRequirementsKHR(VkDevice device, const VkDeviceBufferMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
VkResult vkImportSemaphoreFdKHR(VkDevice device, const VkImportSemaphoreFdInfoKHR *pImportSemaphoreFdInfo)
VkFlags VkShaderStageFlags
Definition: vulkan_core.h:2663
VkFragmentShadingRateNV
Definition: vulkan_core.h:16004
void(* PFN_vkCmdPushDescriptorSet2KHR)(VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfoKHR *pPushDescriptorSetInfo)
Definition: vulkan_core.h:11413
VkResult(* PFN_vkBindAccelerationStructureMemoryNV)(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV *pBindInfos)
Definition: vulkan_core.h:13547
void(* PFN_vkCmdWriteAccelerationStructuresPropertiesNV)(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
Definition: vulkan_core.h:13555
void(* PFN_vkCmdDrawIndexedIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
Definition: vulkan_core.h:9865
void vkCmdCopyMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT *pInfo)
void vkCmdBuildMicromapsEXT(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT *pInfos)
VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats)
VkResult vkCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugUtilsMessengerEXT *pMessenger)
Definition: CreateDebugUtilsMessenger.cpp:29
VkResult(* PFN_vkGetPipelinePropertiesEXT)(VkDevice device, const VkPipelineInfoEXT *pPipelineInfo, VkBaseOutStructure *pPipelineProperties)
Definition: vulkan_core.h:16648
void vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator)
void vkGetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
void(* PFN_vkCmdSetLineStippleEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable)
Definition: vulkan_core.h:17791
VkCopyAccelerationStructureModeKHR
Definition: vulkan_core.h:13322
void vkCmdSetCoverageToColorEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable)
void vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
uint64_t VkDescriptorUpdateTemplate
Definition: vulkan_core.h:4857
VkResult vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImageView *pView)
void vkCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
void vkCmdSetVertexInputEXT(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT *pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT *pVertexAttributeDescriptions)
void vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
VkAccelerationStructureBuildTypeKHR
Definition: vulkan_core.h:16958
void(* PFN_vkCmdSetConservativeRasterizationModeEXT)(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode)
Definition: vulkan_core.h:17784
void(* PFN_vkCmdSetViewportSwizzleNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV *pViewportSwizzles)
Definition: vulkan_core.h:17794
VkResult vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
void vkCmdSetLogicOpEnableEXT(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable)
VkResult vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain)
void vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements)
VkResult(* PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t *pDisplayCount, VkDisplayKHR *pDisplays)
Definition: vulkan_core.h:7863
VkResult vkGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
void(* PFN_vkCmdSetRasterizationStreamEXT)(VkCommandBuffer commandBuffer, uint32_t rasterizationStream)
Definition: vulkan_core.h:17783
void(* PFN_vkCmdEncodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR *pEncodeInfo)
Definition: vulkan_core.h:10654
void vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
void vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties)
void(* PFN_vkCmdCopyMicromapToMemoryEXT)(VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT *pInfo)
Definition: vulkan_core.h:17097
VkResult(* PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
Definition: vulkan_core.h:3995
uint64_t VkDescriptorSetLayout
Definition: vulkan_core.h:118
void vkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer)
void vkGetDeviceImageSparseMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
void vkCmdSetRasterizationStreamEXT(VkCommandBuffer commandBuffer, uint32_t rasterizationStream)
void vkGetDeviceMicromapCompatibilityEXT(VkDevice device, const VkMicromapVersionInfoEXT *pVersionInfo, VkAccelerationStructureCompatibilityKHR *pCompatibility)
void vkCmdSetCoverageToColorLocationNV(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation)
VkResult vkGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void *pData)
VkResult(* PFN_vkUpdateVideoSessionParametersKHR)(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR *pUpdateInfo)
Definition: vulkan_core.h:8160
VkResult(* PFN_vkSetDebugUtilsObjectNameEXT)(VkDevice device, const VkDebugUtilsObjectNameInfoEXT *pNameInfo)
Definition: vulkan_core.h:12731
void vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
VkResult vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR *pModes)
void(* PFN_vkCmdCopyBuffer2KHR)(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 *pCopyBufferInfo)
Definition: vulkan_core.h:10855
uint64_t VkAccelerationStructureKHR
Definition: vulkan_core.h:15736
void vkCmdSetLineStippleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable)
VkResult(* PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT *pInfo, void *pData)
Definition: vulkan_core.h:15876
void(* PFN_vkCmdDrawIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
Definition: vulkan_core.h:9864
VkResult vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties)
VkResult(* PFN_vkAcquireNextImage2KHR)(VkDevice device, const VkAcquireNextImageInfoKHR *pAcquireInfo, uint32_t *pImageIndex)
Definition: vulkan_core.h:7733
VkResult vkCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL *pMarkerInfo)
void(* PFN_vkGetPhysicalDeviceQueueFamilyProperties2)(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
Definition: vulkan_core.h:5555
void vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo *pDependencyInfo)
VkResult vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t *pValue)
VkResult(* PFN_vkGetMemoryFdKHR)(VkDevice device, const VkMemoryGetFdInfoKHR *pGetFdInfo, int *pFd)
Definition: vulkan_core.h:9079
void vkCmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo *pDependencyInfo)
void vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV *pCustomSampleOrders)
VkResult vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
void(* PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:7589
void(* PFN_vkCmdSetRasterizerDiscardEnable)(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable)
Definition: vulkan_core.h:7321
VkResult(* PFN_vkCreateSamplerYcbcrConversion)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
Definition: vulkan_core.h:5560
void(* PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
Definition: vulkan_core.h:11890
void(* PFN_vkGetBufferMemoryRequirements2KHR)(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:9745
void(* PFN_vkGetPhysicalDeviceMemoryProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
Definition: vulkan_core.h:8872
void vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks *pAllocator)
VkResult(* PFN_vkAcquireDrmDisplayEXT)(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display)
Definition: vulkan_core.h:15448
VkResult(* PFN_vkDisplayPowerControlEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT *pDisplayPowerInfo)
Definition: vulkan_core.h:12340
VkResult(* PFN_vkCopyMemoryToAccelerationStructureKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo)
Definition: vulkan_core.h:19032
VkResult(* PFN_vkCopyImageToImageEXT)(VkDevice device, const VkCopyImageToImageInfoEXT *pCopyImageToImageInfo)
Definition: vulkan_core.h:14945
void(* PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE)(VkDevice device, const VkDescriptorSetBindingReferenceVALVE *pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE *pHostMapping)
Definition: vulkan_core.h:17360
VkResult vkGetPhysicalDeviceVideoCapabilitiesKHR(VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR *pVideoProfile, VkVideoCapabilitiesKHR *pCapabilities)
uint32_t vkGetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX *pInfo)
void(* PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
Definition: vulkan_core.h:4043
void vkGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
void(* PFN_vkCmdEndRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
Definition: vulkan_core.h:9315
VkResult(* PFN_vkCreateVideoSessionKHR)(VkDevice device, const VkVideoSessionCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkVideoSessionKHR *pVideoSession)
Definition: vulkan_core.h:8155
void vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties)
void(* PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
Definition: vulkan_core.h:4014
VkResult(* PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSampler *pSampler)
Definition: vulkan_core.h:3983
VkResult vkCreateOpticalFlowSessionNV(VkDevice device, const VkOpticalFlowSessionCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkOpticalFlowSessionNV *pSession)
void(* PFN_vkCmdSetScissorWithCount)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D *pScissors)
Definition: vulkan_core.h:7313
void vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport *pViewports)
void vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo)
void(* PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
Definition: vulkan_core.h:4024
void(* PFN_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers)
Definition: vulkan_core.h:4038
void vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 *pCopyBufferInfo)
VkResult vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
VkResult(* PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool)
Definition: vulkan_core.h:3998
void vkGetDeviceImageSubresourceLayoutKHR(VkDevice device, const VkDeviceImageSubresourceInfoKHR *pInfo, VkSubresourceLayout2KHR *pLayout)
VkResult vkGetEventStatus(VkDevice device, VkEvent event)
void vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve *pRegions)
VkResult vkGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo *pRenderingInfo, VkTilePropertiesQCOM *pProperties)
VkResult(* PFN_vkGetImageDrmFormatModifierPropertiesEXT)(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT *pProperties)
Definition: vulkan_core.h:13087
void vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
void(* PFN_vkCmdExecuteGeneratedCommandsNV)(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
Definition: vulkan_core.h:15262
VkResult vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages)
void vkCmdSetProvokingVertexModeEXT(VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode)
void vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
void vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
void(* PFN_vkQueueEndDebugUtilsLabelEXT)(VkQueue queue)
Definition: vulkan_core.h:12734
void(* PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT)(VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT *pBindDescriptorBufferEmbeddedSamplersInfo)
Definition: vulkan_core.h:11416
void(* PFN_vkGetLatencyTimingsNV)(VkDevice device, VkSwapchainKHR swapchain, VkGetLatencyMarkerInfoNV *pLatencyMarkerInfo)
Definition: vulkan_core.h:18656
uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
void(* PFN_vkCmdSetViewportWScalingNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV *pViewportWScalings)
Definition: vulkan_core.h:12234
VkResult vkCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
void(* PFN_vkCmdWriteBufferMarkerAMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
Definition: vulkan_core.h:13750
VkResult vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
void(* PFN_vkDestroyValidationCacheEXT)(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:13123
VkResult vkMapMemory2KHR(VkDevice device, const VkMemoryMapInfoKHR *pMemoryMapInfo, void **ppData)
void(* PFN_vkCmdCopyMemoryToAccelerationStructureKHR)(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo)
Definition: vulkan_core.h:19036
void(* PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
Definition: vulkan_core.h:8873
uint64_t VkCudaFunctionNV
Definition: vulkan_core.h:15633
VkImageType
Definition: vulkan_core.h:1721
VkResult(* PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPlaneProperties2KHR *pProperties)
Definition: vulkan_core.h:9680
VkResult(* PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout)
Definition: vulkan_core.h:3981
void(* PFN_vkCmdDrawMultiEXT)(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT *pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride)
Definition: vulkan_core.h:16853
VkResult(* PFN_vkSetPrivateDataEXT)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data)
Definition: vulkan_core.h:15558
void vkCmdSetDepthBias2EXT(VkCommandBuffer commandBuffer, const VkDepthBiasInfoEXT *pDepthBiasInfo)
VkResult(* PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR)(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainKHR *pTimeDomains)
Definition: vulkan_core.h:11309
VkResult vkGetRefreshCycleDurationGOOGLE(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE *pDisplayTimingProperties)
VkResult(* PFN_vkInitializePerformanceApiINTEL)(VkDevice device, const VkInitializePerformanceApiInfoINTEL *pInitializeInfo)
Definition: vulkan_core.h:14150
void vkGetMicromapBuildSizesEXT(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT *pBuildInfo, VkMicromapBuildSizesInfoEXT *pSizeInfo)
void vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures)
void(* PFN_vkGetQueueCheckpointDataNV)(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointDataNV *pCheckpointData)
Definition: vulkan_core.h:14035
VkResult(* PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout)
Definition: vulkan_core.h:3985
VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, VkSurfaceCapabilities2KHR *pSurfaceCapabilities)
void vkCmdDrawMeshTasksIndirectCountEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
void(* PFN_vkCmdSetRepresentativeFragmentTestEnableNV)(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable)
Definition: vulkan_core.h:17801
void(* PFN_vkGetPrivateDataEXT)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t *pData)
Definition: vulkan_core.h:15559
void(* PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
Definition: vulkan_core.h:4037
void(* PFN_vkDestroyCudaFunctionNV)(VkDevice device, VkCudaFunctionNV function, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:15684
void vkCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 *pCopyBufferToImageInfo)
void vkCmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo)
VkResult(* PFN_vkQueueSubmit2)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence)
Definition: vulkan_core.h:7300
void vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
VkResult vkGetPipelineExecutableInternalRepresentationsKHR(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR *pInternalRepresentations)
VkResult vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t *pCounterCount, VkPerformanceCounterKHR *pCounters, VkPerformanceCounterDescriptionKHR *pCounterDescriptions)
void(* PFN_vkCmdBindDescriptorSets2KHR)(VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfoKHR *pBindDescriptorSetsInfo)
Definition: vulkan_core.h:11411
VkResult vkGetSwapchainCounterEXT(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t *pCounterValue)
void vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT *pSampleLocationsInfo)
void vkCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
VkResult vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence)
VkResult vkGetShaderBinaryDataEXT(VkDevice device, VkShaderEXT shader, size_t *pDataSize, void *pData)
uint64_t VkSamplerYcbcrConversion
Definition: vulkan_core.h:4856
void vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
void(* PFN_vkCmdSetVertexInputEXT)(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT *pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT *pVertexAttributeDescriptions)
Definition: vulkan_core.h:16452
void(* PFN_vkCmdSetPrimitiveTopologyEXT)(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology)
Definition: vulkan_core.h:14763
VkResult vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR *pAcquireInfo, uint32_t *pImageIndex)
void vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
VkResult vkCopyMemoryToMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT *pInfo)
VkResult vkWriteAccelerationStructuresPropertiesKHR(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, size_t dataSize, void *pData, size_t stride)
VkResult(* PFN_vkRegisterDisplayEventEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT *pDisplayEventInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
Definition: vulkan_core.h:12342
VkResult vkReleaseSwapchainImagesEXT(VkDevice device, const VkReleaseSwapchainImagesInfoEXT *pReleaseInfo)
void(* PFN_vkGetQueueCheckpointData2NV)(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointData2NV *pCheckpointData)
Definition: vulkan_core.h:10727
void(* PFN_vkGetDeviceGroupPeerMemoryFeatures)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
Definition: vulkan_core.h:5544
void vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
VkResult(* PFN_vkCreateValidationCacheEXT)(VkDevice device, const VkValidationCacheCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkValidationCacheEXT *pValidationCache)
Definition: vulkan_core.h:13122
void vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void *pCheckpointMarker)
void(* PFN_vkCmdSetProvokingVertexModeEXT)(VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode)
Definition: vulkan_core.h:17789
void(* PFN_vkDestroyAccelerationStructureNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:13545
void vkQueueNotifyOutOfBandNV(VkQueue queue, const VkOutOfBandQueueTypeInfoNV *pQueueTypeInfo)
VkResult vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pRectCount, VkRect2D *pRects)
VkResult(* PFN_vkGetDeviceFaultInfoEXT)(VkDevice device, VkDeviceFaultCountsEXT *pFaultCounts, VkDeviceFaultInfoEXT *pFaultInfo)
Definition: vulkan_core.h:16356
void vkCmdCopyMemoryToMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT *pInfo)
void(* PFN_vkCmdSetDescriptorBufferOffsets2EXT)(VkCommandBuffer commandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT *pSetDescriptorBufferOffsetsInfo)
Definition: vulkan_core.h:11415
void(* PFN_vkDestroyVideoSessionParametersKHR)(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:8161
void vkCmdBindDescriptorSets2KHR(VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfoKHR *pBindDescriptorSetsInfo)
VkPrimitiveTopology
Definition: vulkan_core.h:1979
VkResult vkGetFramebufferTilePropertiesQCOM(VkDevice device, VkFramebuffer framebuffer, uint32_t *pPropertiesCount, VkTilePropertiesQCOM *pProperties)
void(* PFN_vkDebugReportMessageEXT)(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char *pLayerPrefix, const char *pMessage)
Definition: vulkan_core.h:11529
VkResult(* PFN_vkBindVideoSessionMemoryKHR)(VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR *pBindSessionMemoryInfos)
Definition: vulkan_core.h:8158
void(* PFN_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
Definition: vulkan_core.h:9258
void vkCmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR *pInfo)
void(* PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
Definition: vulkan_core.h:4013
VkFlags VkCullModeFlags
Definition: vulkan_core.h:2633
void vkDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks *pAllocator)
Definition: CreateDebugUtilsMessenger.cpp:37
VkFlags VkDeviceGroupPresentModeFlagsKHR
Definition: vulkan_core.h:7648
void vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator)
void vkGetImageSubresourceLayout2EXT(VkDevice device, VkImage image, const VkImageSubresource2KHR *pSubresource, VkSubresourceLayout2KHR *pLayout)
void(* PFN_vkCmdCopyImageToBuffer2KHR)(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo)
Definition: vulkan_core.h:10858
void vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query)
VkResult(* PFN_vkCreateDescriptorUpdateTemplateKHR)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
Definition: vulkan_core.h:9256
VkResult(* PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache)
Definition: vulkan_core.h:3974
VkResult vkGetImageViewAddressNVX(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX *pProperties)
uint64_t VkPipeline
Definition: vulkan_core.h:116
void(* PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
Definition: vulkan_core.h:11634
void vkCmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable)
void(* PFN_vkCmdWaitEvents2)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, const VkDependencyInfo *pDependencyInfos)
Definition: vulkan_core.h:7297
VkFilter
Definition: vulkan_core.h:2046
void(* PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
Definition: vulkan_core.h:4041
void vkGetDeviceImageSparseMemoryRequirementsKHR(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
void vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors)
void(* PFN_vkCmdSetPatchControlPointsEXT)(VkCommandBuffer commandBuffer, uint32_t patchControlPoints)
Definition: vulkan_core.h:16727
VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPlaneProperties2KHR *pProperties)
VkFlags VkQueryResultFlags
Definition: vulkan_core.h:2464
void(* PFN_vkCmdBindTransformFeedbackBuffersEXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes)
Definition: vulkan_core.h:11725
void(* PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions)
Definition: vulkan_core.h:4029
uint64_t VkDebugUtilsMessengerEXT
Definition: vulkan_core.h:12652
void(* PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve *pRegions)
Definition: vulkan_core.h:4035
void vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable)
void vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
void vkGetDescriptorSetLayoutSizeEXT(VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize *pLayoutSizeInBytes)
void(* PFN_vkGetDeviceImageMemoryRequirements)(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:7325
VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
void vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp)
VkResult(* PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer)
Definition: vulkan_core.h:4004
void(* PFN_vkGetDescriptorSetHostMappingVALVE)(VkDevice device, VkDescriptorSet descriptorSet, void **ppData)
Definition: vulkan_core.h:17361
VkFlags VkImageCreateFlags
Definition: vulkan_core.h:2280
void(* PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions)
Definition: vulkan_core.h:4026
void vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
VkResult(* PFN_vkImportSemaphoreFdKHR)(VkDevice device, const VkImportSemaphoreFdInfoKHR *pImportSemaphoreFdInfo)
Definition: vulkan_core.h:9154
VkResult(* PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats)
Definition: vulkan_core.h:7592
void(* PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
Definition: vulkan_core.h:4006
void vkCmdDrawClusterHUAWEI(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
VkResult vkGetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR *pMemoryFdProperties)
void(* PFN_vkCmdSubpassShadingHUAWEI)(VkCommandBuffer commandBuffer)
Definition: vulkan_core.h:16569
void vkGetLatencyTimingsNV(VkDevice device, VkSwapchainKHR swapchain, VkGetLatencyMarkerInfoNV *pLatencyMarkerInfo)
void vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo)
VkFrontFace
Definition: vulkan_core.h:1967
void(* PFN_vkGetDescriptorSetLayoutSupportKHR)(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
Definition: vulkan_core.h:9850
void vkUninitializePerformanceApiINTEL(VkDevice device)
void vkDestroyMicromapEXT(VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks *pAllocator)
void(* PFN_vkCmdSetColorBlendAdvancedEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT *pColorBlendAdvanced)
Definition: vulkan_core.h:17788
void(* PFN_vkGetDeviceImageSparseMemoryRequirementsKHR)(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
Definition: vulkan_core.h:10958
void vkSetLatencyMarkerNV(VkDevice device, VkSwapchainKHR swapchain, const VkSetLatencyMarkerInfoNV *pLatencyMarkerInfo)
VkResult(* PFN_vkTransitionImageLayoutEXT)(VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfoEXT *pTransitions)
Definition: vulkan_core.h:14946
void(* PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t *pPropertyCount, VkSparseImageFormatProperties *pProperties)
Definition: vulkan_core.h:3946
void(* PFN_vkCmdSetDepthTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable)
Definition: vulkan_core.h:14767
VkResult vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *pTagInfo)
VkResult(* PFN_vkGetFenceStatus)(VkDevice device, VkFence fence)
Definition: vulkan_core.h:3951
VkResult(* PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
Definition: vulkan_core.h:3979
void vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
VkResult(* PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex)
Definition: vulkan_core.h:7728
void vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth)
void(* PFN_vkGetDeviceImageSubresourceLayoutKHR)(VkDevice device, const VkDeviceImageSubresourceInfoKHR *pInfo, VkSubresourceLayout2KHR *pLayout)
Definition: vulkan_core.h:11115
void(* PFN_vkCmdDrawMeshTasksIndirectEXT)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
Definition: vulkan_core.h:19340
uint64_t(* PFN_vkGetBufferOpaqueCaptureAddress)(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
Definition: vulkan_core.h:6400
void(* PFN_vkCmdCopyMicromapEXT)(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT *pInfo)
Definition: vulkan_core.h:17096
void vkCmdTraceRaysKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth)
void(* PFN_vkCmdNextSubpass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo)
Definition: vulkan_core.h:9314
void vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements *pSparseMemoryRequirements)
void vkGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
VkResult(* PFN_vkGetPipelineExecutableInternalRepresentationsKHR)(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR *pInternalRepresentations)
Definition: vulkan_core.h:10395
VkResult vkGetMemoryRemoteAddressNV(VkDevice device, const VkMemoryGetRemoteAddressInfoNV *pMemoryGetRemoteAddressInfo, VkRemoteAddressNV *pAddress)
void(* PFN_vkGetPhysicalDeviceMemoryProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
Definition: vulkan_core.h:5556
VkResult(* PFN_vkCreateRayTracingPipelinesNV)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
Definition: vulkan_core.h:13551
void vkCmdDrawMeshTasksEXT(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
void vkCmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable)
void(* PFN_vkCmdCopyMemoryIndirectNV)(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride)
Definition: vulkan_core.h:17495
void(* PFN_vkCmdPipelineBarrier2KHR)(VkCommandBuffer commandBuffer, const VkDependencyInfo *pDependencyInfo)
Definition: vulkan_core.h:10723
VkResult vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout)
void(* PFN_vkTrimCommandPoolKHR)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
Definition: vulkan_core.h:8978
void vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask)
void(* PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:7726
VkResult(* PFN_vkBindImageMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
Definition: vulkan_core.h:5543
void(* PFN_vkCmdSetDepthBiasEnable)(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable)
Definition: vulkan_core.h:7322
VkResult(* PFN_vkSetEvent)(VkDevice device, VkEvent event)
Definition: vulkan_core.h:3958
VkResult(* PFN_vkGetMemoryRemoteAddressNV)(VkDevice device, const VkMemoryGetRemoteAddressInfoNV *pMemoryGetRemoteAddressInfo, VkRemoteAddressNV *pAddress)
Definition: vulkan_core.h:16620
void(* PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects)
Definition: vulkan_core.h:4034
void(* PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers)
Definition: vulkan_core.h:4039
struct VkCommandBuffer_T * VkCommandBuffer
Definition: vulkan_core.h:106
void vkCmdSetColorWriteMaskEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags *pColorWriteMasks)
VkResult(* PFN_vkReleaseSwapchainImagesEXT)(VkDevice device, const VkReleaseSwapchainImagesInfoEXT *pReleaseInfo)
Definition: vulkan_core.h:15090
void(* PFN_vkCmdSetDepthCompareOpEXT)(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp)
Definition: vulkan_core.h:14769
void vkGetDescriptorSetLayoutHostMappingInfoVALVE(VkDevice device, const VkDescriptorSetBindingReferenceVALVE *pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE *pHostMapping)
VkResult(* PFN_vkMapMemory2KHR)(VkDevice device, const VkMemoryMapInfoKHR *pMemoryMapInfo, void **ppData)
Definition: vulkan_core.h:10439
VkResult(* PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage)
Definition: vulkan_core.h:3967
void(* PFN_vkCmdOpticalFlowExecuteNV)(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV *pExecuteInfo)
Definition: vulkan_core.h:18216
void vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
VkResult(* PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore)
Definition: vulkan_core.h:3953
VkResult(* PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice)
Definition: vulkan_core.h:3924
VkResult(* PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
Definition: vulkan_core.h:3941
void vkCmdSubpassShadingHUAWEI(VkCommandBuffer commandBuffer)
void vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
void(* PFN_vkCmdBindIndexBuffer2KHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType)
Definition: vulkan_core.h:11113
void(* PFN_vkGetImageSubresourceLayout2KHR)(VkDevice device, VkImage image, const VkImageSubresource2KHR *pSubresource, VkSubresourceLayout2KHR *pLayout)
Definition: vulkan_core.h:11116
void vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointDataNV *pCheckpointData)
VkResult(* PFN_vkCreateCuFunctionNVX)(VkDevice device, const VkCuFunctionCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCuFunctionNVX *pFunction)
Definition: vulkan_core.h:11817
void vkGetShaderModuleCreateInfoIdentifierEXT(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, VkShaderModuleIdentifierEXT *pIdentifier)
uint64_t vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
void vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
void vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator)
VkResult vkGetDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR *pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR *pCapabilities)
void(* PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties *pFormatProperties)
Definition: vulkan_core.h:3917
VkResult(* PFN_vkBindOpticalFlowSessionImageNV)(VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout)
Definition: vulkan_core.h:18215
void(* PFN_vkCmdBindShadingRateImageNV)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
Definition: vulkan_core.h:13256
VkResult vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore)
void vkCmdSetSampleLocationsEnableEXT(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable)
void(* PFN_vkDestroyVideoSessionKHR)(VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:8156
void vkCmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, const VkDependencyInfo *pDependencyInfos)
void vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
VkResult(* PFN_vkGetDisplayModeProperties2KHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t *pPropertyCount, VkDisplayModeProperties2KHR *pProperties)
Definition: vulkan_core.h:9681
VkDeviceAddress(* PFN_vkGetBufferDeviceAddress)(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
Definition: vulkan_core.h:6399
VkResult vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool)
VkFlags VkDebugReportFlagsEXT
Definition: vulkan_core.h:11508
VkResult vkMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT *pSrcCaches)
VkResult(* PFN_vkWaitForPresentKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout)
Definition: vulkan_core.h:10239
void vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkSubpassContents contents)
void vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D *pExclusiveScissors)
void(* PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers)
Definition: vulkan_core.h:4049
void vkCmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress)
VkResult vkGetDeviceFaultInfoEXT(VkDevice device, VkDeviceFaultCountsEXT *pFaultCounts, VkDeviceFaultInfoEXT *pFaultInfo)
void vkCmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex)
void vkGetDescriptorSetLayoutBindingOffsetEXT(VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize *pOffset)
VkResult vkGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR *pGetFdInfo, int *pFd)
void(* PFN_vkCmdSetShadingRateImageEnableNV)(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable)
Definition: vulkan_core.h:17800
void vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
void vkCmdBindShadersEXT(VkCommandBuffer commandBuffer, uint32_t stageCount, const VkShaderStageFlagBits *pStages, const VkShaderEXT *pShaders)
VkResult vkAcquirePerformanceConfigurationINTEL(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL *pAcquireInfo, VkPerformanceConfigurationINTEL *pConfiguration)
VkResult(* PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDisplayModeKHR *pMode)
Definition: vulkan_core.h:7865
void(* PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors)
Definition: vulkan_core.h:4008
void(* PFN_vkGetPhysicalDeviceExternalFenceProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties)
Definition: vulkan_core.h:5566
uint64_t VkDebugReportCallbackEXT
Definition: vulkan_core.h:11447
void vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable)
void(* PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3949
void(* PFN_vkCmdEndVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR *pEndCodingInfo)
Definition: vulkan_core.h:8163
VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainKHR *pTimeDomains)
void(* PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource *pSubresource, VkSubresourceLayout *pLayout)
Definition: vulkan_core.h:3969
void vkCmdDrawClusterIndirectHUAWEI(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
void(* PFN_vkGetDeviceImageSparseMemoryRequirements)(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
Definition: vulkan_core.h:7326
VkResult vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPropertiesKHR *pProperties)
void vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers)
void(* PFN_vkCmdSetCheckpointNV)(VkCommandBuffer commandBuffer, const void *pCheckpointMarker)
Definition: vulkan_core.h:14034
void(* PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3984
void(* PFN_vkCmdSetDepthWriteEnable)(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable)
Definition: vulkan_core.h:7316
void vkDestroyCuFunctionNVX(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks *pAllocator)
uint64_t VkSemaphore
Definition: vulkan_core.h:105
void(* PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies)
Definition: vulkan_core.h:3992
VkResult(* PFN_vkGetPhysicalDeviceToolPropertiesEXT)(VkPhysicalDevice physicalDevice, uint32_t *pToolCount, VkPhysicalDeviceToolProperties *pToolProperties)
Definition: vulkan_core.h:14430
void vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
void vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo)
VkResult vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
VkDeviceAddress(* PFN_vkGetPipelineIndirectDeviceAddressNV)(VkDevice device, const VkPipelineIndirectDeviceAddressInfoNV *pInfo)
Definition: vulkan_core.h:17597
VkResult vkWaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout)
VkResult(* PFN_vkCompileDeferredNV)(VkDevice device, VkPipeline pipeline, uint32_t shader)
Definition: vulkan_core.h:13556
VkPresentModeKHR
Definition: vulkan_core.h:7517
VkResult(* PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer)
Definition: vulkan_core.h:3993
void(* PFN_vkCmdCopyMemoryToImageIndirectNV)(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers *pImageSubresources)
Definition: vulkan_core.h:17496
void vkCmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology)
void(* PFN_vkGetDescriptorSetLayoutSizeEXT)(VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize *pLayoutSizeInBytes)
Definition: vulkan_core.h:15870
void vkDestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks *pAllocator)
void(* PFN_vkGetPhysicalDeviceExternalBufferProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties)
Definition: vulkan_core.h:5565
uint64_t VkCuFunctionNVX
Definition: vulkan_core.h:11782
VkResult vkCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureKHR *pAccelerationStructure)
void(* PFN_vkQueueBeginDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
Definition: vulkan_core.h:12733
void(* PFN_vkCmdSetStencilOpEXT)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp)
Definition: vulkan_core.h:14772
void(* PFN_vkCmdSetCoverageModulationTableEnableNV)(VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable)
Definition: vulkan_core.h:17798
void vkGetDescriptorEXT(VkDevice device, const VkDescriptorGetInfoEXT *pDescriptorInfo, size_t dataSize, void *pDescriptor)
void vkCmdSetCoverageModulationModeNV(VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode)
void(* PFN_vkCmdCopyAccelerationStructureNV)(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode)
Definition: vulkan_core.h:13549
VkResult(* PFN_vkCopyMicromapEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT *pInfo)
Definition: vulkan_core.h:17092
VkResult vkTransitionImageLayoutEXT(VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfoEXT *pTransitions)
VkResult(* PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory)
Definition: vulkan_core.h:3934
void vkDestroyDeferredOperationKHR(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks *pAllocator)
void vkDestroyCudaFunctionNV(VkDevice device, VkCudaFunctionNV function, const VkAllocationCallbacks *pAllocator)
VkResult vkSetEvent(VkDevice device, VkEvent event)
void(* PFN_vkCmdBindInvocationMaskHUAWEI)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
Definition: vulkan_core.h:16592
VkResult(* PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
Definition: vulkan_core.h:3989
VkLineRasterizationModeEXT
Definition: vulkan_core.h:14656
void vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
void vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions)
VkResult vkDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT *pNameInfo)
VkResult(* PFN_vkGetCudaModuleCacheNV)(VkDevice device, VkCudaModuleNV module, size_t *pCacheSize, void *pCacheData)
Definition: vulkan_core.h:15681
VkResult(* PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices)
Definition: vulkan_core.h:3915
VkResult vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool)
VkFormat
Definition: vulkan_core.h:1406
VkSubpassContents
Definition: vulkan_core.h:2138
VkResult vkCreateVideoSessionParametersKHR(VkDevice device, const VkVideoSessionParametersCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkVideoSessionParametersKHR *pVideoSessionParameters)
void vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
VkResult(* PFN_vkCreatePrivateDataSlotEXT)(VkDevice device, const VkPrivateDataSlotCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPrivateDataSlot *pPrivateDataSlot)
Definition: vulkan_core.h:15556
void(* PFN_vkGetImageSparseMemoryRequirements2KHR)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
Definition: vulkan_core.h:9746
void(* PFN_vkCmdSetPolygonModeEXT)(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode)
Definition: vulkan_core.h:17774
uint64_t VkPrivateDataSlot
Definition: vulkan_core.h:6482
void vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator)
VkResult(* PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties *pImageFormatProperties)
Definition: vulkan_core.h:3918
void vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp)
uint64_t VkDeviceAddress
Definition: vulkan_core.h:95
VkResult vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(VkPhysicalDevice physicalDevice, uint32_t *pCombinationCount, VkFramebufferMixedSamplesCombinationNV *pCombinations)
VkResult vkGetEncodedVideoSessionParametersKHR(VkDevice device, const VkVideoEncodeSessionParametersGetInfoKHR *pVideoSessionParametersInfo, VkVideoEncodeSessionParametersFeedbackInfoKHR *pFeedbackInfo, size_t *pDataSize, void *pData)
VkFlags VkDescriptorPoolResetFlags
Definition: vulkan_core.h:2686
void vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable)
VkResult(* PFN_vkSignalSemaphoreKHR)(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
Definition: vulkan_core.h:10084
VkResult(* PFN_vkWriteAccelerationStructuresPropertiesKHR)(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, size_t dataSize, void *pData, size_t stride)
Definition: vulkan_core.h:19033
VkResult(* PFN_vkGetDisplayPlaneCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR *pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR *pCapabilities)
Definition: vulkan_core.h:9682
void vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties)
void(* PFN_vkCmdSetViewportWithCount)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport *pViewports)
Definition: vulkan_core.h:7312
void vkCmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp)
void vkCmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace)
void(* PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3964
void(* PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements *pSparseMemoryRequirements)
Definition: vulkan_core.h:3945
void vkDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks *pAllocator)
VkResult vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties *pImageFormatProperties)
VkResult(* PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void **ppData)
Definition: vulkan_core.h:3936
void vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
void vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const VkDependencyInfo *pDependencyInfo)
void vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer)
void(* PFN_vkDestroyShaderEXT)(VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:18330
uint64_t vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
void(* PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:3968
VkResult vkAcquireProfilingLockKHR(VkDevice device, const VkAcquireProfilingLockInfoKHR *pInfo)
void(* PFN_vkCmdDrawClusterHUAWEI)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
Definition: vulkan_core.h:17215
void vkCmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
void vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator)
VkResult(* PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
Definition: vulkan_core.h:19221
void(* PFN_vkDestroyDebugUtilsMessengerEXT)(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:12740
void vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies)
VkResult vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout)
void vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
VkResult(* PFN_vkDebugMarkerSetObjectTagEXT)(VkDevice device, const VkDebugMarkerObjectTagInfoEXT *pTagInfo)
Definition: vulkan_core.h:11632
void(* PFN_vkGetPhysicalDeviceFeatures2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
Definition: vulkan_core.h:8867
VkResult(* PFN_vkGetAccelerationStructureHandleNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void *pData)
Definition: vulkan_core.h:13554
void vkGetRenderingAreaGranularityKHR(VkDevice device, const VkRenderingAreaInfoKHR *pRenderingAreaInfo, VkExtent2D *pGranularity)
void vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties)
uint64_t VkPerformanceConfigurationINTEL
Definition: vulkan_core.h:14063
VkResult(* PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData)
Definition: vulkan_core.h:3976
void vkCmdSetCoverageModulationTableNV(VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float *pCoverageModulationTable)
void(* PFN_vkDestroyPrivateDataSlotEXT)(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:15557
void vkCmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2 *pResolveImageInfo)
void vkCmdSetExtraPrimitiveOverestimationSizeEXT(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize)
VkResult(* PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 *pSupported)
Definition: vulkan_core.h:7590
void vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator)
VkResult(* PFN_vkCopyAccelerationStructureToMemoryKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo)
Definition: vulkan_core.h:19031
VkResult(* PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool)
Definition: vulkan_core.h:3987
void vkGetPipelineIndirectMemoryRequirementsNV(VkDevice device, const VkComputePipelineCreateInfo *pCreateInfo, VkMemoryRequirements2 *pMemoryRequirements)
VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPlanePropertiesKHR *pProperties)
void(* PFN_vkCmdDecompressMemoryNV)(VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV *pDecompressMemoryRegions)
Definition: vulkan_core.h:17547
VkResult(* PFN_vkMergeValidationCachesEXT)(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT *pSrcCaches)
Definition: vulkan_core.h:13124
VkResult vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkEvent *pEvent)
PFN_vkVoidFunction vkGetDeviceProcAddr(VkDevice device, const char *pName)
VkResult vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences)
VkResult vkCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL *pMarkerInfo)
VkResult(* PFN_vkGetDeviceGroupPresentCapabilitiesKHR)(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities)
Definition: vulkan_core.h:7730
void vkCmdSetPolygonModeEXT(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode)
void(* PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties)
Definition: vulkan_core.h:9112
void vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
void vkCmdEndVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR *pEndCodingInfo)
VkResult(* PFN_vkGetDrmDisplayEXT)(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR *display)
Definition: vulkan_core.h:15449
void vkGetAccelerationStructureMemoryRequirementsNV(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2KHR *pMemoryRequirements)
VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesNV *pProperties)
VkPolygonMode
Definition: vulkan_core.h:1994
uint64_t(* PFN_vkGetDeviceMemoryOpaqueCaptureAddress)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
Definition: vulkan_core.h:6401
void(* PFN_vkCmdWriteTimestamp2KHR)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query)
Definition: vulkan_core.h:10724
void vkCmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D *pScissors)
VkFlags64 VkPipelineStageFlags2
Definition: vulkan_core.h:6512
void vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
void vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
uint32_t VkBool32
Definition: vulkan_core.h:94
VkResult vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(VkDevice device, VkRenderPass renderpass, VkExtent2D *pMaxWorkgroupSize)
void(* PFN_vkDestroySamplerYcbcrConversionKHR)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:9800
VkResult vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
uint64_t VkImageView
Definition: vulkan_core.h:112
void(* PFN_vkDestroyCudaModuleNV)(VkDevice device, VkCudaModuleNV module, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:15683
VkResult vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence)
VkResult vkGetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR *pGetFdInfo, int *pFd)
VkPipelineStageFlagBits
Definition: vulkan_core.h:2369
VkResult vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties)
void vkCmdSetAttachmentFeedbackLoopEnableEXT(VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask)
void vkCmdSetShadingRateImageEnableNV(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable)
VkResult(* PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool)
Definition: vulkan_core.h:3960
void(* PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
Definition: vulkan_core.h:4010
void vkCmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode)
VkResult vkCopyMemoryToAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo)
void vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer)
void(* PFN_vkCmdEndRendering)(VkCommandBuffer commandBuffer)
Definition: vulkan_core.h:7308
void(* PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory)
Definition: vulkan_core.h:3937
void(* PFN_vkCmdPushConstants2KHR)(VkCommandBuffer commandBuffer, const VkPushConstantsInfoKHR *pPushConstantsInfo)
Definition: vulkan_core.h:11412
void(* PFN_vkReleaseProfilingLockKHR)(VkDevice device)
Definition: vulkan_core.h:9549
VkResult vkCreateDisplayPlaneSurfaceKHR(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
void vkGetAccelerationStructureBuildSizesKHR(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR *pBuildInfo, const uint32_t *pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR *pSizeInfo)
VkResult(* PFN_vkCreateCudaFunctionNV)(VkDevice device, const VkCudaFunctionCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCudaFunctionNV *pFunction)
Definition: vulkan_core.h:15682
void vkCmdCopyMicromapToMemoryEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT *pInfo)
VkResult vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micromapCount, const VkMicromapEXT *pMicromaps, VkQueryType queryType, size_t dataSize, void *pData, size_t stride)
VkResult(* PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV)(VkPhysicalDevice physicalDevice, uint32_t *pCombinationCount, VkFramebufferMixedSamplesCombinationNV *pCombinations)
Definition: vulkan_core.h:14561
VkDeviceAddress(* PFN_vkGetBufferDeviceAddressEXT)(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
Definition: vulkan_core.h:14411
VkResult(* PFN_vkCopyAccelerationStructureKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR *pInfo)
Definition: vulkan_core.h:19030
void(* PFN_vkCmdSetDeviceMask)(VkCommandBuffer commandBuffer, uint32_t deviceMask)
Definition: vulkan_core.h:5545
VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities)
void(* PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets)
Definition: vulkan_core.h:4018
VkResult(* PFN_vkCreateVideoSessionParametersKHR)(VkDevice device, const VkVideoSessionParametersCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkVideoSessionParametersKHR *pVideoSessionParameters)
Definition: vulkan_core.h:8159
void(* PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements)
Definition: vulkan_core.h:3944
VkResult vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer)
VkDiscardRectangleModeEXT
Definition: vulkan_core.h:12488
void(* PFN_vkUpdateDescriptorSetWithTemplate)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
Definition: vulkan_core.h:5564
void(* PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue)
Definition: vulkan_core.h:3930
void(* PFN_vkCmdCopyBufferToImage2KHR)(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 *pCopyBufferToImageInfo)
Definition: vulkan_core.h:10857
void vkCmdSetTessellationDomainOriginEXT(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin)
void vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointData2NV *pCheckpointData)
void(* PFN_vkCmdDrawMeshTasksNV)(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask)
Definition: vulkan_core.h:13934
VkResult vkGetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR *pGetFdInfo, int *pFd)
VkResult(* PFN_vkReleasePerformanceConfigurationINTEL)(VkDevice device, VkPerformanceConfigurationINTEL configuration)
Definition: vulkan_core.h:14156
VkObjectType
Definition: vulkan_core.h:1323
VkResult(* PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR)(VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR *pVideoProfile, VkVideoCapabilitiesKHR *pCapabilities)
Definition: vulkan_core.h:8153
VkResult(* PFN_vkEnumerateInstanceVersion)(uint32_t *pApiVersion)
Definition: vulkan_core.h:5541
VkResult(* PFN_vkGetSemaphoreCounterValue)(VkDevice device, VkSemaphore semaphore, uint64_t *pValue)
Definition: vulkan_core.h:6396
void(* PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
Definition: vulkan_core.h:4022
void vkCmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
VkResult(* PFN_vkSetLatencySleepModeNV)(VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepModeInfoNV *pSleepModeInfo)
Definition: vulkan_core.h:18653
void vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions)
void vkCmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable)
VkResult vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices)
void vkCmdTraceRaysNV(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth)
void(* PFN_vkCmdWriteTimestamp2)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query)
Definition: vulkan_core.h:7299
VkResult vkEndCommandBuffer(VkCommandBuffer commandBuffer)
void(* PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth)
Definition: vulkan_core.h:4009
void vkDestroyShaderEXT(VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks *pAllocator)
VkResult(* PFN_vkGetPhysicalDeviceDisplayProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayProperties2KHR *pProperties)
Definition: vulkan_core.h:9679
VkResult(* PFN_vkBindImageMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
Definition: vulkan_core.h:9825
void(* PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize *pCommittedMemoryInBytes)
Definition: vulkan_core.h:3940
VkResult vkBindOpticalFlowSessionImageNV(VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout)
VkResult vkSetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data)
VkResult(* PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo, VkCommandBuffer *pCommandBuffers)
Definition: vulkan_core.h:4001
VkResult(* PFN_vkAcquirePerformanceConfigurationINTEL)(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL *pAcquireInfo, VkPerformanceConfigurationINTEL *pConfiguration)
Definition: vulkan_core.h:14155
void vkCmdSetColorBlendEquationEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT *pColorBlendEquations)
void vkCmdEndRenderPass(VkCommandBuffer commandBuffer)
void vkCmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask)
void vkCmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp)
void vkGetShaderModuleIdentifierEXT(VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT *pIdentifier)
void(* PFN_vkDestroyCuModuleNVX)(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks *pAllocator)
Definition: vulkan_core.h:11818
VkResult vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, uint32_t *pSurfaceFormatCount, VkSurfaceFormat2KHR *pSurfaceFormats)
void vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers)
VkResult vkGetVideoSessionMemoryRequirementsKHR(VkDevice device, VkVideoSessionKHR videoSession, uint32_t *pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR *pMemoryRequirements)
void(* PFN_vkCmdSetViewportWithCountEXT)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport *pViewports)
Definition: vulkan_core.h:14764
VkResult vkImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR *pImportFenceFdInfo)
VkResult vkCreateAccelerationStructureNV(VkDevice device, const VkAccelerationStructureCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureNV *pAccelerationStructure)
VkResult(* PFN_vkSetDebugUtilsObjectTagEXT)(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *pTagInfo)
Definition: vulkan_core.h:12732
void vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV *pShadingRatePalettes)
VkDeviceAddress(* PFN_vkGetAccelerationStructureDeviceAddressKHR)(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR *pInfo)
Definition: vulkan_core.h:19037
VkResult vkGetPipelinePropertiesEXT(VkDevice device, const VkPipelineInfoEXT *pPipelineInfo, VkBaseOutStructure *pPipelineProperties)
VkProvokingVertexModeEXT
Definition: vulkan_core.h:14602
VkResult vkCreateCuFunctionNVX(VkDevice device, const VkCuFunctionCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCuFunctionNVX *pFunction)
VkResult vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
uint64_t VkDeviceMemory
Definition: vulkan_core.h:108
VkResult(* PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR *pPresentInfo)
Definition: vulkan_core.h:7729
void(* PFN_vkGetPipelineIndirectMemoryRequirementsNV)(VkDevice device, const VkComputePipelineCreateInfo *pCreateInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:17595
void(* PFN_vkCmdEndQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
Definition: vulkan_core.h:11729
VkResult(* PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo)
Definition: vulkan_core.h:4003
VkResult(* PFN_vkQueueSetPerformanceConfigurationINTEL)(VkQueue queue, VkPerformanceConfigurationINTEL configuration)
Definition: vulkan_core.h:14157
void vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
VkResult(* PFN_vkGetImageOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkImageCaptureDescriptorDataInfoEXT *pInfo, void *pData)
Definition: vulkan_core.h:15877
void(* PFN_vkCmdDrawMultiIndexedEXT)(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT *pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t *pVertexOffset)
Definition: vulkan_core.h:16854
void(* PFN_vkCmdSetLineStippleEXT)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern)
Definition: vulkan_core.h:14689
void vkCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
void(* PFN_vkCmdSetDeviceMaskKHR)(VkCommandBuffer commandBuffer, uint32_t deviceMask)
Definition: vulkan_core.h:8938
VkResult(* PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesKHR *pProperties)
Definition: vulkan_core.h:11225
VkResult vkGetCalibratedTimestampsKHR(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation)
VkResult vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets)
void(* PFN_vkCmdSetRayTracingPipelineStackSizeKHR)(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize)
Definition: vulkan_core.h:19224
void(* PFN_vkCmdDrawIndexedIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
Definition: vulkan_core.h:6390
VkResult vkGetImageOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageCaptureDescriptorDataInfoEXT *pInfo, void *pData)
void vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects)
void vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator)
void(* PFN_vkCmdWriteAccelerationStructuresPropertiesKHR)(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
Definition: vulkan_core.h:19038
uint64_t VkValidationCacheEXT
Definition: vulkan_core.h:13099
VkResult(* PFN_vkGetSemaphoreFdKHR)(VkDevice device, const VkSemaphoreGetFdInfoKHR *pGetFdInfo, int *pFd)
Definition: vulkan_core.h:9155
VkResult vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
void(* PFN_vkGetShaderModuleIdentifierEXT)(VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT *pIdentifier)
Definition: vulkan_core.h:18063
void vkCmdWriteMicromapsPropertiesEXT(VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT *pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
void(* PFN_vkGetPhysicalDeviceFeatures2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
Definition: vulkan_core.h:5551
VkResult(* PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
Definition: vulkan_core.h:3978
void vkCmdSetRasterizationSamplesEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples)
void vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
VkResult vkGetPastPresentationTimingGOOGLE(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pPresentationTimingCount, VkPastPresentationTimingGOOGLE *pPresentationTimings)
uint32_t(* PFN_vkGetDeferredOperationMaxConcurrencyKHR)(VkDevice device, VkDeferredOperationKHR operation)
Definition: vulkan_core.h:10298
VkFlags VkCommandBufferResetFlags
Definition: vulkan_core.h:2780
VkResult vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo, VkCommandBuffer *pCommandBuffers)
void vkCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
void(* PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set)
Definition: vulkan_core.h:15875
VkResult(* PFN_vkGetPipelineExecutableStatisticsKHR)(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pStatisticCount, VkPipelineExecutableStatisticKHR *pStatistics)
Definition: vulkan_core.h:10394
void vkDestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks *pAllocator)
void vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
void vkCmdEncodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR *pEncodeInfo)
VkResult(* PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches)
Definition: vulkan_core.h:3977
uint64_t vkGetBufferOpaqueCaptureAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
VkResult(* PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, uint32_t *pSurfaceFormatCount, VkSurfaceFormat2KHR *pSurfaceFormats)
Definition: vulkan_core.h:9618
uint64_t VkVideoSessionKHR
Definition: vulkan_core.h:7945
VkResult(* PFN_vkCreateRenderPass2)(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
Definition: vulkan_core.h:6391
VkResult vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo)
VkResult vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout)
void(* PFN_vkGetDeviceBufferMemoryRequirementsKHR)(VkDevice device, const VkDeviceBufferMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
Definition: vulkan_core.h:10956
void(* PFN_vkCmdEndDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer)
Definition: vulkan_core.h:12737
VkResult vkGetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t *pToolCount, VkPhysicalDeviceToolProperties *pToolProperties)
VkFlags VkColorComponentFlags
Definition: vulkan_core.h:2540
VkDebugUtilsMessageSeverityFlagBitsEXT
Definition: vulkan_core.h:12657
void(* PFN_vkCmdCopyAccelerationStructureToMemoryKHR)(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo)
Definition: vulkan_core.h:19035
#define VULKAN_HPP_CONST_OR_CONSTEXPR
Definition: vulkan_hpp_macros.hpp:156
#define VULKAN_HPP_ASSERT
Definition: vulkan_hpp_macros.hpp:63
#define VULKAN_HPP_NODISCARD
Definition: vulkan_hpp_macros.hpp:195
#define VULKAN_HPP_NAMESPACE_STRING
Definition: vulkan_hpp_macros.hpp:205
#define VULKAN_HPP_RAII_CREATE_NOEXCEPT
Definition: vulkan_hpp_macros.hpp:294
#define VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT
Definition: vulkan_hpp_macros.hpp:276
#define VULKAN_HPP_NOEXCEPT
Definition: vulkan_hpp_macros.hpp:171
#define VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT
Definition: vulkan_hpp_macros.hpp:275
#define VULKAN_HPP_CONSTEXPR_14
Definition: vulkan_hpp_macros.hpp:155
#define VULKAN_HPP_INLINE
Definition: vulkan_hpp_macros.hpp:130